diff --git a/arcanist/linter/IncludeGuardLinter.php b/arcanist/linter/IncludeGuardLinter.php
index c9f0aae5e..849157552 100644
--- a/arcanist/linter/IncludeGuardLinter.php
+++ b/arcanist/linter/IncludeGuardLinter.php
@@ -1,71 +1,72 @@
 <?php
 
 /**
  * Check the include guard matches the rules from the developer notes.
  */
 final class IncludeGuardLinter extends ArcanistLinter {
 
   const GUARD_PREFIX = 'BITCOIN_';
   const GUARD_SUFFIX = '_H';
 
   const INCLUDE_GUARD_INVALID = 1;
 
   public function getInfoName() {
     return 'lint-include-guard';
   }
 
   public function getInfoDescription() {
     return pht('Check the include guard matches the rules from the developer '.
                'notes. ');
   }
 
   public function getLinterName() {
     return 'INCLUDE_GUARD';
   }
 
   public function getLinterConfigurationName() {
     return 'lint-include-guard';
   }
 
   public function getLintSeverityMap() {
     return array(
       self::INCLUDE_GUARD_INVALID => ArcanistLintSeverity::SEVERITY_ERROR,
     );
   }
 
   public function getLintNameMap() {
     return array(
       self::INCLUDE_GUARD_INVALID => pht('Include guard malformed or missing.'),
     );
   }
 
   public function lintPath($path) {
     $abspath = Filesystem::resolvePath($path, $this->getProjectRoot());
     $fileContent = Filesystem::readFile($abspath);
 
     $pathInfo = pathinfo($path);
 
     // Get the path components. They are relative to project root.
     $guard = explode('/', $pathInfo['dirname']);
     // Add the file name (without extension) to the path components.
     $guard[] = $pathInfo['filename'];
     // Skip the upper 'src' directory
     $guard = array_slice($guard, 1);
     // Join to a string using an underscore ('_') as the delimiter.
     $guard = implode('_', $guard);
     // Transform the whole string to uppercase.
     $guard = strtoupper($guard);
     // Surround with prefix and suffix.
     $guard = self::GUARD_PREFIX.$guard.self::GUARD_SUFFIX;
 
-    if (preg_match_all('/#(?:ifndef|define) '.$guard.'/', $fileContent) != 2) {
+    if (preg_match_all('@#(?:ifndef|define|endif //) '.$guard.'@',
+      $fileContent) != 3) {
       return $this->raiseLintAtPath(
         self::INCLUDE_GUARD_INVALID,
         pht("Include guard is malformed or missing. Expected format:\n".
           "\t#ifndef %s\n".
           "\t#define %s\n".
           "\t...\n".
           "\t#endif // %s", $guard, $guard, $guard));
     }
   }
 }
diff --git a/src/amount.h b/src/amount.h
index 8abe957ee..0400a4c6d 100644
--- a/src/amount.h
+++ b/src/amount.h
@@ -1,173 +1,173 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AMOUNT_H
 #define BITCOIN_AMOUNT_H
 
 #include <serialize.h>
 
 #include <cstdlib>
 #include <ostream>
 #include <string>
 #include <type_traits>
 
 struct Amount {
 private:
     int64_t amount;
 
     explicit constexpr Amount(int64_t _amount) : amount(_amount) {}
 
 public:
     constexpr Amount() : amount(0) {}
     constexpr Amount(const Amount &other) : amount(other.amount) {}
 
     /**
      * Assignement operator.
      */
     constexpr Amount &operator=(const Amount &other) {
         amount = other.amount;
         return *this;
     }
 
     static constexpr Amount zero() { return Amount(0); }
     static constexpr Amount satoshi() { return Amount(1); }
 
     /**
      * Implement standard operators
      */
     Amount &operator+=(const Amount a) {
         amount += a.amount;
         return *this;
     }
     Amount &operator-=(const Amount a) {
         amount -= a.amount;
         return *this;
     }
 
     /**
      * Equality
      */
     friend constexpr bool operator==(const Amount a, const Amount b) {
         return a.amount == b.amount;
     }
     friend constexpr bool operator!=(const Amount a, const Amount b) {
         return !(a == b);
     }
 
     /**
      * Comparison
      */
     friend constexpr bool operator<(const Amount a, const Amount b) {
         return a.amount < b.amount;
     }
     friend constexpr bool operator>(const Amount a, const Amount b) {
         return b < a;
     }
     friend constexpr bool operator<=(const Amount a, const Amount b) {
         return !(a > b);
     }
     friend constexpr bool operator>=(const Amount a, const Amount b) {
         return !(a < b);
     }
 
     /**
      * Unary minus
      */
     constexpr Amount operator-() const { return Amount(-amount); }
 
     /**
      * Addition and subtraction.
      */
     friend constexpr Amount operator+(const Amount a, const Amount b) {
         return Amount(a.amount + b.amount);
     }
     friend constexpr Amount operator-(const Amount a, const Amount b) {
         return a + -b;
     }
 
     /**
      * Multiplication
      */
     friend constexpr Amount operator*(const int64_t a, const Amount b) {
         return Amount(a * b.amount);
     }
     friend constexpr Amount operator*(const int a, const Amount b) {
         return Amount(a * b.amount);
     }
 
     /**
      * Division
      */
     constexpr int64_t operator/(const Amount b) const {
         return amount / b.amount;
     }
     constexpr Amount operator/(const int64_t b) const {
         return Amount(amount / b);
     }
     constexpr Amount operator/(const int b) const { return Amount(amount / b); }
     Amount &operator/=(const int64_t n) {
         amount /= n;
         return *this;
     }
 
     /**
      * Modulus
      */
     constexpr Amount operator%(const Amount b) const {
         return Amount(amount % b.amount);
     }
     constexpr Amount operator%(const int64_t b) const {
         return Amount(amount % b);
     }
     constexpr Amount operator%(const int b) const { return Amount(amount % b); }
 
     /**
      * Do not implement double ops to get an error with double and ensure
      * casting to integer is explicit.
      */
     friend constexpr Amount operator*(const double a, const Amount b) = delete;
     constexpr Amount operator/(const double b) const = delete;
     constexpr Amount operator%(const double b) const = delete;
 
     // ostream support
     friend std::ostream &operator<<(std::ostream &stream, const Amount &ca) {
         return stream << ca.amount;
     }
 
     std::string ToString() const;
 
     // serialization support
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(amount);
     }
 };
 
 static constexpr Amount SATOSHI = Amount::satoshi();
 static constexpr Amount CASH = 100 * SATOSHI;
 static constexpr Amount COIN = 100000000 * SATOSHI;
 static constexpr Amount CENT = COIN / 100;
 
 extern const std::string CURRENCY_UNIT;
 
 /**
  * No amount larger than this (in satoshi) is valid.
  *
  * Note that this constant is *not* the total money supply, which in Bitcoin
  * currently happens to be less than 21,000,000 BCH for various reasons, but
  * rather a sanity check. As this sanity check is used by consensus-critical
  * validation code, the exact value of the MAX_MONEY constant is consensus
  * critical; in unusual circumstances like a(nother) overflow bug that allowed
  * for the creation of coins out of thin air modification could lead to a fork.
  */
 static const Amount MAX_MONEY = 21000000 * COIN;
 inline bool MoneyRange(const Amount nValue) {
     return nValue >= Amount::zero() && nValue <= MAX_MONEY;
 }
 
-#endif //  BITCOIN_AMOUNT_H
+#endif // BITCOIN_AMOUNT_H
diff --git a/src/cashaddrenc.h b/src/cashaddrenc.h
index 7b0d715fe..323042962 100644
--- a/src/cashaddrenc.h
+++ b/src/cashaddrenc.h
@@ -1,32 +1,32 @@
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_CASHADDRENC_H
 #define BITCOIN_CASHADDRENC_H
 
 #include <script/standard.h>
 
 #include <string>
 #include <vector>
 
 class CChainParams;
 
 enum CashAddrType : uint8_t { PUBKEY_TYPE = 0, SCRIPT_TYPE = 1 };
 
 struct CashAddrContent {
     CashAddrType type;
     std::vector<uint8_t> hash;
 };
 
 std::string EncodeCashAddr(const CTxDestination &, const CChainParams &);
 std::string EncodeCashAddr(const std::string &prefix,
                            const CashAddrContent &content);
 
 CTxDestination DecodeCashAddr(const std::string &addr,
                               const CChainParams &params);
 CashAddrContent DecodeCashAddrContent(const std::string &addr,
                                       const std::string &prefix);
 CTxDestination DecodeCashAddrDestination(const CashAddrContent &content);
 
 std::vector<uint8_t> PackCashAddrContent(const CashAddrContent &content);
-#endif
+#endif // BITCOIN_CASHADDRENC_H
diff --git a/src/config.h b/src/config.h
index 40d2e1ece..a9d83192c 100644
--- a/src/config.h
+++ b/src/config.h
@@ -1,109 +1,109 @@
 // Copyright (c) 2017 Amaury SÉCHET
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_CONFIG_H
 #define BITCOIN_CONFIG_H
 
 #include <amount.h>
 #include <feerate.h>
 
 #include <boost/noncopyable.hpp>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
 class CChainParams;
 
 class Config : public boost::noncopyable {
 public:
     virtual bool SetMaxBlockSize(uint64_t maxBlockSize) = 0;
     virtual uint64_t GetMaxBlockSize() const = 0;
     virtual bool
     SetBlockPriorityPercentage(int64_t blockPriorityPercentage) = 0;
     virtual uint8_t GetBlockPriorityPercentage() const = 0;
     virtual const CChainParams &GetChainParams() const = 0;
     virtual void SetCashAddrEncoding(bool) = 0;
     virtual bool UseCashAddrEncoding() const = 0;
 
     virtual void SetExcessUTXOCharge(Amount amt) = 0;
     virtual Amount GetExcessUTXOCharge() const = 0;
 
     virtual void SetRPCUserAndPassword(std::string userAndPassword) = 0;
     virtual std::string GetRPCUserAndPassword() const = 0;
     virtual void SetRPCCORSDomain(std::string corsDomain) = 0;
     virtual std::string GetRPCCORSDomain() const = 0;
 };
 
 class GlobalConfig final : public Config {
 public:
     GlobalConfig();
     bool SetMaxBlockSize(uint64_t maxBlockSize) override;
     uint64_t GetMaxBlockSize() const override;
     bool SetBlockPriorityPercentage(int64_t blockPriorityPercentage) override;
     uint8_t GetBlockPriorityPercentage() const override;
     const CChainParams &GetChainParams() const override;
     void SetCashAddrEncoding(bool) override;
     bool UseCashAddrEncoding() const override;
 
     void SetExcessUTXOCharge(Amount) override;
     Amount GetExcessUTXOCharge() const override;
 
     void SetRPCUserAndPassword(std::string userAndPassword) override;
     std::string GetRPCUserAndPassword() const override;
     void SetRPCCORSDomain(std::string corsDomain) override;
     std::string GetRPCCORSDomain() const override;
 
 private:
     bool useCashAddr;
     Amount excessUTXOCharge;
 
     /** RPC authentication configs */
 
     // Pre-base64-encoded authentication token, with user and password separated
     // by a colon.
     std::string rpcUserAndPassword;
     // CORS domain, the allowed Origin
     std::string rpcCORSDomain;
 
     /** The largest block size this node will accept. */
     uint64_t nMaxBlockSize;
     uint64_t nBlockPriorityPercentage;
 };
 
 // Dummy for subclassing in unittests
 class DummyConfig : public Config {
 public:
     DummyConfig();
     DummyConfig(std::string net);
     DummyConfig(std::unique_ptr<CChainParams> chainParamsIn);
     bool SetMaxBlockSize(uint64_t maxBlockSize) override { return false; }
     uint64_t GetMaxBlockSize() const override { return 0; }
     bool SetBlockPriorityPercentage(int64_t blockPriorityPercentage) override {
         return false;
     }
     uint8_t GetBlockPriorityPercentage() const override { return 0; }
 
     void SetChainParams(std::string net);
     const CChainParams &GetChainParams() const override { return *chainParams; }
 
     void SetCashAddrEncoding(bool) override {}
     bool UseCashAddrEncoding() const override { return false; }
 
     void SetExcessUTXOCharge(Amount amt) override {}
     Amount GetExcessUTXOCharge() const override { return Amount::zero(); }
 
     void SetRPCUserAndPassword(std::string userAndPassword) override{};
     std::string GetRPCUserAndPassword() const override { return ""; };
     void SetRPCCORSDomain(std::string corsDomain) override{};
     std::string GetRPCCORSDomain() const override { return ""; };
 
 private:
     std::unique_ptr<CChainParams> chainParams;
 };
 
 // Temporary woraround.
 const Config &GetConfig();
 
-#endif
+#endif // BITCOIN_CONFIG_H
diff --git a/src/feerate.h b/src/feerate.h
index ae5c2b785..a4f971f50 100644
--- a/src/feerate.h
+++ b/src/feerate.h
@@ -1,95 +1,95 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_FEERATE_H
 #define BITCOIN_FEERATE_H
 
 #include <amount.h>
 #include <serialize.h>
 
 #include <cstdlib>
 #include <ostream>
 #include <string>
 #include <type_traits>
 
 /**
  * Fee rate in satoshis per kilobyte: Amount / kB
  */
 class CFeeRate {
 private:
     // unit is satoshis-per-1,000-bytes
     Amount nSatoshisPerK;
 
 public:
     /**
      * Fee rate of 0 satoshis per kB.
      */
     constexpr CFeeRate() : nSatoshisPerK() {}
     explicit constexpr CFeeRate(const Amount _nSatoshisPerK)
         : nSatoshisPerK(_nSatoshisPerK) {}
 
     /**
      * Constructor for a fee rate in satoshis per kB. The size in bytes must not
      * exceed (2^63 - 1)
      */
     CFeeRate(const Amount nFeePaid, size_t nBytes);
 
     /**
      * Return the fee in satoshis for the given size in bytes.
      */
     Amount GetFee(size_t nBytes) const;
 
     /**
      * Return the ceiling of a fee calculation in satoshis for the given size in
      * bytes.
      */
     Amount GetFeeCeiling(size_t nBytes) const;
 
     /**
      * Return the fee in satoshis for a size of 1000 bytes
      */
     Amount GetFeePerK() const { return GetFee(1000); }
 
     /**
      * Equality
      */
     friend constexpr bool operator==(const CFeeRate a, const CFeeRate b) {
         return a.nSatoshisPerK == b.nSatoshisPerK;
     }
     friend constexpr bool operator!=(const CFeeRate a, const CFeeRate b) {
         return !(a == b);
     }
 
     /**
      * Comparison
      */
     friend bool operator<(const CFeeRate &a, const CFeeRate &b) {
         return a.nSatoshisPerK < b.nSatoshisPerK;
     }
     friend bool operator>(const CFeeRate &a, const CFeeRate &b) {
         return a.nSatoshisPerK > b.nSatoshisPerK;
     }
     friend bool operator<=(const CFeeRate &a, const CFeeRate &b) {
         return a.nSatoshisPerK <= b.nSatoshisPerK;
     }
     friend bool operator>=(const CFeeRate &a, const CFeeRate &b) {
         return a.nSatoshisPerK >= b.nSatoshisPerK;
     }
     CFeeRate &operator+=(const CFeeRate &a) {
         nSatoshisPerK += a.nSatoshisPerK;
         return *this;
     }
     std::string ToString() const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(nSatoshisPerK);
     }
 };
 
-#endif //  BITCOIN_FEERATE_H
+#endif // BITCOIN_FEERATE_H
diff --git a/src/httprpc.h b/src/httprpc.h
index baf25dba7..e9669994e 100644
--- a/src/httprpc.h
+++ b/src/httprpc.h
@@ -1,64 +1,64 @@
 // Copyright (c) 2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_HTTPRPC_H
 #define BITCOIN_HTTPRPC_H
 
 #include <httpserver.h>
 #include <rpc/server.h>
 
 #include <map>
 #include <string>
 
 class Config;
 
 class HTTPRPCRequestProcessor {
 private:
     Config &config;
     RPCServer &rpcServer;
 
     bool ProcessHTTPRequest(HTTPRequest *request);
 
 public:
     HTTPRPCRequestProcessor(Config &configIn, RPCServer &rpcServerIn)
         : config(configIn), rpcServer(rpcServerIn) {}
 
     static bool DelegateHTTPRequest(HTTPRPCRequestProcessor *requestProcessor,
                                     HTTPRequest *request) {
         return requestProcessor->ProcessHTTPRequest(request);
     }
 };
 
 /**
  * Start HTTP RPC subsystem.
  * Precondition; HTTP and RPC has been started.
  */
 bool StartHTTPRPC(Config &config,
                   HTTPRPCRequestProcessor &httpRPCRequestProcessor);
 
 /** Interrupt HTTP RPC subsystem */
 void InterruptHTTPRPC();
 
 /**
  * Stop HTTP RPC subsystem.
  * Precondition; HTTP and RPC has been stopped.
  */
 void StopHTTPRPC();
 
 /**
  * Start HTTP REST subsystem.
  * Precondition; HTTP and RPC has been started.
  */
 bool StartREST();
 
 /** Interrupt RPC REST subsystem */
 void InterruptREST();
 
 /**
  * Stop HTTP REST subsystem.
  * Precondition; HTTP and RPC has been stopped.
  */
 void StopREST();
 
-#endif
+#endif // BITCOIN_HTTPRPC_H
diff --git a/src/qt/test/bitcoinaddressvalidatortests.h b/src/qt/test/bitcoinaddressvalidatortests.h
index d0e76eadf..1584f5c1d 100644
--- a/src/qt/test/bitcoinaddressvalidatortests.h
+++ b/src/qt/test/bitcoinaddressvalidatortests.h
@@ -1,18 +1,18 @@
 // Copyright (c) 2017 The Bitcoin Developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_TEST_BITCOINADDRESSVALIDATORTESTS_H
 #define BITCOIN_QT_TEST_BITCOINADDRESSVALIDATORTESTS_H
 
 #include <QObject>
 #include <QTest>
 
 class BitcoinAddressValidatorTests : public QObject {
     Q_OBJECT
 
 private Q_SLOTS:
     void inputTests();
 };
 
-#endif
+#endif // BITCOIN_QT_TEST_BITCOINADDRESSVALIDATORTESTS_H
diff --git a/src/rpc/mining.h b/src/rpc/mining.h
index f8805b5dd..03759b0af 100644
--- a/src/rpc/mining.h
+++ b/src/rpc/mining.h
@@ -1,21 +1,21 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_RPC_MINING_H
 #define BITCOIN_RPC_MINING_H
 
 #include <script/script.h>
 
 #include <univalue.h>
 
 #include <memory>
 
 class Config;
 
 /** Generate blocks (mine) */
 UniValue generateBlocks(const Config &config,
                         std::shared_ptr<CReserveScript> coinbaseScript,
                         int nGenerate, uint64_t nMaxTries, bool keepScript);
 
-#endif
+#endif // BITCOIN_RPC_MINING_H
diff --git a/src/scheduler.h b/src/scheduler.h
index 3b935014a..e96e6c4a0 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -1,133 +1,133 @@
 // Copyright (c) 2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCHEDULER_H
 #define BITCOIN_SCHEDULER_H
 
 #include <sync.h>
 
 //
 // NOTE:
 // boost::thread / boost::chrono should be ported to
 // std::thread / std::chrono when we support C++11.
 //
 #include <boost/chrono/chrono.hpp>
 #include <boost/thread.hpp>
 
 #include <map>
 
 //
 // Simple class for background tasks that should be run periodically or once
 // "after a while"
 //
 // Usage:
 //
 // CScheduler* s = new CScheduler();
 // s->scheduleFromNow(doSomething, 11); // Assuming a: void doSomething() { }
 // s->scheduleFromNow(std::bind(Class::func, this, argument), 3);
 // boost::thread* t = new boost::thread(std::bind(CScheduler::serviceQueue, s));
 //
 // ... then at program shutdown, clean up the thread running serviceQueue:
 // t->interrupt();
 // t->join();
 // delete t;
 // delete s; // Must be done after thread is interrupted/joined.
 //
 
 class CScheduler {
 public:
     CScheduler();
     ~CScheduler();
 
     typedef std::function<void()> Function;
     typedef std::function<bool()> Predicate;
 
     // Call func at/after time t
     void schedule(Function f, boost::chrono::system_clock::time_point t =
                                   boost::chrono::system_clock::now());
 
     // Convenience method: call f once deltaMilliSeconds from now
     void scheduleFromNow(Function f, int64_t deltaMilliSeconds);
 
     // Another convenience method: call p approximately every deltaMilliSeconds
     // forever, starting deltaMilliSeconds from now untill p returns false. To
     // be more precise: every time p is finished, it is rescheduled to run
     // deltaMilliSeconds later. If you need more accurate scheduling, don't use
     // this method.
     void scheduleEvery(Predicate p, int64_t deltaMilliSeconds);
 
     // To keep things as simple as possible, there is no unschedule.
 
     // Services the queue 'forever'. Should be run in a thread, and interrupted
     // using boost::interrupt_thread
     void serviceQueue();
 
     // Tell any threads running serviceQueue to stop as soon as they're done
     // servicing whatever task they're currently servicing (drain=false) or when
     // there is no work left to be done (drain=true)
     void stop(bool drain = false);
 
     // Returns number of tasks waiting to be serviced, and first and last task
     // times
     size_t getQueueInfo(boost::chrono::system_clock::time_point &first,
                         boost::chrono::system_clock::time_point &last) const;
 
     // Returns true if there are threads actively running in serviceQueue()
     bool AreThreadsServicingQueue() const;
 
 private:
     std::multimap<boost::chrono::system_clock::time_point, Function> taskQueue;
     boost::condition_variable newTaskScheduled;
     mutable boost::mutex newTaskMutex;
     int nThreadsServicingQueue;
     bool stopRequested;
     bool stopWhenEmpty;
     bool shouldStop() const {
         return stopRequested || (stopWhenEmpty && taskQueue.empty());
     }
 };
 
 /**
  * Class used by CScheduler clients which may schedule multiple jobs
  * which are required to be run serially. Jobs may not be run on the
  * same thread, but no two jobs will be executed
  * at the same time and memory will be release-acquire consistent
  * (the scheduler will internally do an acquire before invoking a callback
  * as well as a release at the end). In practice this means that a callback
  * B() will be able to observe all of the effects of callback A() which executed
  * before it.
  */
 class SingleThreadedSchedulerClient {
 private:
     CScheduler *m_pscheduler;
 
     CCriticalSection m_cs_callbacks_pending;
     std::list<std::function<void()>>
         m_callbacks_pending GUARDED_BY(m_cs_callbacks_pending);
     bool m_are_callbacks_running GUARDED_BY(m_cs_callbacks_pending) = false;
 
     void MaybeScheduleProcessQueue();
     void ProcessQueue();
 
 public:
     explicit SingleThreadedSchedulerClient(CScheduler *pschedulerIn)
         : m_pscheduler(pschedulerIn) {}
 
     /**
      * Add a callback to be executed. Callbacks are executed serially
      * and memory is release-acquire consistent between callback executions.
      * Practially, this means that callbacks can behave as if they are executed
      * in order by a single thread.
      */
     void AddToProcessQueue(std::function<void()> func);
 
     // Processes all remaining queue members on the calling thread, blocking
     // until queue is empty. Must be called after the CScheduler has no
     // remaining processing threads!
     void EmptyQueue();
 
     size_t CallbacksPending();
 };
 
-#endif
+#endif // BITCOIN_SCHEDULER_H
diff --git a/src/seeder/bitcoin.h b/src/seeder/bitcoin.h
index c84984907..2b2dd5eb2 100644
--- a/src/seeder/bitcoin.h
+++ b/src/seeder/bitcoin.h
@@ -1,25 +1,25 @@
 #ifndef BITCOIN_SEEDER_BITCOIN_H
 #define BITCOIN_SEEDER_BITCOIN_H
 
 #include <protocol.h>
 
 #include <string>
 #include <vector>
 
 /**
  * The seeder do not use the Params facility.
  *
  * While this is sorted out, we need a replacement.
  */
 extern bool fTestNet;
 static inline unsigned short GetDefaultPort(const bool testnet = fTestNet) {
     return testnet ? 18333 : 8333;
 }
 
 // The network magic to use.
 extern CMessageHeader::MessageMagic netMagic;
 
 bool TestNode(const CService &cip, int &ban, int &client, std::string &clientSV,
               int &blocks, std::vector<CAddress> *vAddr);
 
-#endif
+#endif // BITCOIN_SEEDER_BITCOIN_H
diff --git a/src/seeder/db.h b/src/seeder/db.h
index 7efe657f7..d131185f3 100644
--- a/src/seeder/db.h
+++ b/src/seeder/db.h
@@ -1,448 +1,448 @@
 #ifndef BITCOIN_SEEDER_DB_H
 #define BITCOIN_SEEDER_DB_H
 
 #include <netbase.h>
 #include <protocol.h>
 #include <seeder/bitcoin.h>
 #include <seeder/util.h>
 #include <sync.h>
 #include <version.h>
 
 #include <cmath>
 #include <cstdint>
 #include <deque>
 #include <map>
 #include <set>
 #include <vector>
 
 #define MIN_RETRY 1000
 
 #define REQUIRE_VERSION 70001
 
 static inline int GetRequireHeight(const bool testnet = fTestNet) {
     return testnet ? 500000 : 350000;
 }
 
 static inline std::string ToString(const CService &ip) {
     std::string str = ip.ToString();
     while (str.size() < 22) {
         str += ' ';
     }
     return str;
 }
 
 class CAddrStat {
 private:
     float weight;
     float count;
     float reliability;
 
 public:
     CAddrStat() : weight(0), count(0), reliability(0) {}
 
     void Update(bool good, int64_t age, double tau) {
         double f = exp(-age / tau);
         reliability = reliability * f + (good ? (1.0 - f) : 0);
         count = count * f + 1;
         weight = weight * f + (1.0 - f);
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(weight);
         READWRITE(count);
         READWRITE(reliability);
     }
 
     friend class CAddrInfo;
 };
 
 class CAddrReport {
 public:
     CService ip;
     int clientVersion;
     int blocks;
     double uptime[5];
     std::string clientSubVersion;
     int64_t lastSuccess;
     bool fGood;
     uint64_t services;
 };
 
 class CAddrInfo {
 private:
     CService ip;
     uint64_t services;
     int64_t lastTry;
     int64_t ourLastTry;
     int64_t ourLastSuccess;
     int64_t ignoreTill;
     CAddrStat stat2H;
     CAddrStat stat8H;
     CAddrStat stat1D;
     CAddrStat stat1W;
     CAddrStat stat1M;
     int clientVersion;
     int blocks;
     int total;
     int success;
     std::string clientSubVersion;
 
 public:
     CAddrInfo()
         : services(0), lastTry(0), ourLastTry(0), ourLastSuccess(0),
           ignoreTill(0), clientVersion(0), blocks(0), total(0), success(0) {}
 
     CAddrReport GetReport() const {
         CAddrReport ret;
         ret.ip = ip;
         ret.clientVersion = clientVersion;
         ret.clientSubVersion = clientSubVersion;
         ret.blocks = blocks;
         ret.uptime[0] = stat2H.reliability;
         ret.uptime[1] = stat8H.reliability;
         ret.uptime[2] = stat1D.reliability;
         ret.uptime[3] = stat1W.reliability;
         ret.uptime[4] = stat1M.reliability;
         ret.lastSuccess = ourLastSuccess;
         ret.fGood = IsGood();
         ret.services = services;
         return ret;
     }
 
     bool IsGood() const {
         if (ip.GetPort() != GetDefaultPort()) return false;
         if (!(services & NODE_NETWORK)) return false;
         if (!ip.IsRoutable()) return false;
         if (clientVersion && clientVersion < REQUIRE_VERSION) return false;
         if (blocks && blocks < GetRequireHeight()) return false;
 
         if (total <= 3 && success * 2 >= total) return true;
 
         if (stat2H.reliability > 0.85 && stat2H.count > 2) return true;
         if (stat8H.reliability > 0.70 && stat8H.count > 4) return true;
         if (stat1D.reliability > 0.55 && stat1D.count > 8) return true;
         if (stat1W.reliability > 0.45 && stat1W.count > 16) return true;
         if (stat1M.reliability > 0.35 && stat1M.count > 32) return true;
 
         return false;
     }
 
     int64_t GetBanTime() const {
         if (IsGood()) {
             return 0;
         }
         if (clientVersion && clientVersion < 31900) {
             return 604800;
         }
         if (stat1M.reliability - stat1M.weight + 1.0 < 0.15 &&
             stat1M.count > 32) {
             return 30 * 86400;
         }
         if (stat1W.reliability - stat1W.weight + 1.0 < 0.10 &&
             stat1W.count > 16) {
             return 7 * 86400;
         }
         if (stat1D.reliability - stat1D.weight + 1.0 < 0.05 &&
             stat1D.count > 8) {
             return 1 * 86400;
         }
         return 0;
     }
 
     int64_t GetIgnoreTime() const {
         if (IsGood()) {
             return 0;
         }
         if (stat1M.reliability - stat1M.weight + 1.0 < 0.20 &&
             stat1M.count > 2) {
             return 10 * 86400;
         }
         if (stat1W.reliability - stat1W.weight + 1.0 < 0.16 &&
             stat1W.count > 2) {
             return 3 * 86400;
         }
         if (stat1D.reliability - stat1D.weight + 1.0 < 0.12 &&
             stat1D.count > 2) {
             return 8 * 3600;
         }
         if (stat8H.reliability - stat8H.weight + 1.0 < 0.08 &&
             stat8H.count > 2) {
             return 2 * 3600;
         }
         return 0;
     }
 
     void Update(bool good);
 
     friend class CAddrDb;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         uint8_t version = 4;
         READWRITE(version);
         READWRITE(ip);
         READWRITE(services);
         READWRITE(lastTry);
         uint8_t tried = ourLastTry != 0;
         READWRITE(tried);
         if (!tried) {
             return;
         }
 
         READWRITE(ourLastTry);
         READWRITE(ignoreTill);
         READWRITE(stat2H);
         READWRITE(stat8H);
         READWRITE(stat1D);
         READWRITE(stat1W);
         if (version >= 1) {
             READWRITE(stat1M);
         } else if (!ser_action.ForRead()) {
             *((CAddrStat *)(&stat1M)) = stat1W;
         }
         READWRITE(total);
         READWRITE(success);
         READWRITE(clientVersion);
         if (version >= 2) READWRITE(clientSubVersion);
         if (version >= 3) READWRITE(blocks);
         if (version >= 4) READWRITE(ourLastSuccess);
     }
 };
 
 class CAddrDbStats {
 public:
     int nBanned;
     int nAvail;
     int nTracked;
     int nNew;
     int nGood;
     int nAge;
 };
 
 struct CServiceResult {
     CService service;
     bool fGood;
     int nBanTime;
     int nHeight;
     int nClientV;
     std::string strClientV;
     int64_t ourLastSuccess;
 };
 
 /**
  *             seen nodes
  *            /          \
  * (a) banned nodes       available nodes--------------
  *                       /       |                     \
  *               tracked nodes   (b) unknown nodes   (e) active nodes
  *              /           \
  *     (d) good nodes   (c) non-good nodes
  */
 class CAddrDb {
 private:
     mutable CCriticalSection cs;
     // number of address id's
     int nId;
     // map address id to address info (b,c,d,e)
     std::map<int, CAddrInfo> idToInfo;
     // map ip to id (b,c,d,e)
     std::map<CService, int> ipToId;
     // sequence of tried nodes, in order we have tried connecting to them (c,d)
     std::deque<int> ourId;
     // set of nodes not yet tried (b)
     std::set<int> unkId;
     // set of good nodes  (d, good e)
     std::set<int> goodId;
     int nDirty;
 
 protected:
     // internal routines that assume proper locks are acquired
     // add an address
     void Add_(const CAddress &addr, bool force);
     // get an IP to test (must call Good_, Bad_, or Skipped_ on result
     // afterwards)
     bool Get_(CServiceResult &ip, int &wait);
     bool GetMany_(std::vector<CServiceResult> &ips, int max, int &wait);
     // mark an IP as good (must have been returned by Get_)
     void Good_(const CService &ip, int clientV, std::string clientSV,
                int blocks);
     // mark an IP as bad (and optionally ban it) (must have been returned by
     // Get_)
     void Bad_(const CService &ip, int ban);
     // mark an IP as skipped (must have been returned by Get_)
     void Skipped_(const CService &ip);
     // look up id of an IP
     int Lookup_(const CService &ip);
     // get a random set of IPs (shared lock only)
     void GetIPs_(std::set<CNetAddr> &ips, uint64_t requestedFlags, uint32_t max,
                  const bool *nets);
 
 public:
     // nodes that are banned, with their unban time (a)
     std::map<CService, int64_t> banned;
 
     void GetStats(CAddrDbStats &stats) const {
         LOCK(cs);
         stats.nBanned = banned.size();
         stats.nAvail = idToInfo.size();
         stats.nTracked = ourId.size();
         stats.nGood = goodId.size();
         stats.nNew = unkId.size();
         if (ourId.size() > 0) {
             stats.nAge = time(nullptr) - idToInfo.at(ourId.at(0)).ourLastTry;
         } else {
             stats.nAge = 0;
         }
     }
 
     void ResetIgnores() {
         for (std::map<int, CAddrInfo>::iterator it = idToInfo.begin();
              it != idToInfo.end(); it++) {
             (*it).second.ignoreTill = 0;
         }
     }
 
     std::vector<CAddrReport> GetAll() {
         std::vector<CAddrReport> ret;
         LOCK(cs);
         for (std::deque<int>::const_iterator it = ourId.begin();
              it != ourId.end(); it++) {
             const CAddrInfo &info = idToInfo[*it];
             if (info.success > 0) {
                 ret.push_back(info.GetReport());
             }
         }
         return ret;
     }
 
     // serialization code
     // format:
     //   nVersion (0 for now)
     //   n (number of ips in (b,c,d))
     //   CAddrInfo[n]
     //   banned
     // acquires a shared lock (this does not suffice for read mode, but we
     // assume that only happens at startup, single-threaded) this way, dumping
     // does not interfere with GetIPs_, which is called from the DNS thread
     template <typename Stream> void Serialize(Stream &s) const {
         LOCK(cs);
 
         int nVersion = 0;
         s << nVersion;
 
         CAddrDb *db = const_cast<CAddrDb *>(this);
         int n = ourId.size() + unkId.size();
         s << n;
         for (std::deque<int>::const_iterator it = ourId.begin();
              it != ourId.end(); it++) {
             std::map<int, CAddrInfo>::iterator ci = db->idToInfo.find(*it);
             s << (*ci).second;
         }
         for (std::set<int>::const_iterator it = unkId.begin();
              it != unkId.end(); it++) {
             std::map<int, CAddrInfo>::iterator ci = db->idToInfo.find(*it);
             s << (*ci).second;
         }
         s << banned;
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         LOCK(cs);
 
         int nVersion;
         s >> nVersion;
 
         CAddrDb *db = const_cast<CAddrDb *>(this);
         db->nId = 0;
         int n;
         s >> n;
         for (int i = 0; i < n; i++) {
             CAddrInfo info;
             s >> info;
             if (!info.GetBanTime()) {
                 int id = db->nId++;
                 db->idToInfo[id] = info;
                 db->ipToId[info.ip] = id;
                 if (info.ourLastTry) {
                     db->ourId.push_back(id);
                     if (info.IsGood()) db->goodId.insert(id);
                 } else {
                     db->unkId.insert(id);
                 }
             }
         }
         db->nDirty++;
 
         s >> banned;
     }
 
     void Add(const CAddress &addr, bool fForce = false) {
         LOCK(cs);
         Add_(addr, fForce);
     }
 
     void Add(const std::vector<CAddress> &vAddr, bool fForce = false) {
         LOCK(cs);
         for (size_t i = 0; i < vAddr.size(); i++) {
             Add_(vAddr[i], fForce);
         }
     }
 
     void Good(const CService &addr, int clientVersion,
               std::string clientSubVersion, int blocks) {
         LOCK(cs);
         Good_(addr, clientVersion, clientSubVersion, blocks);
     }
 
     void Skipped(const CService &addr) {
         LOCK(cs);
         Skipped_(addr);
     }
 
     void Bad(const CService &addr, int ban = 0) {
         LOCK(cs);
         Bad_(addr, ban);
     }
 
     bool Get(CServiceResult &ip, int &wait) {
         LOCK(cs);
         return Get_(ip, wait);
     }
 
     void GetMany(std::vector<CServiceResult> &ips, int max, int &wait) {
         LOCK(cs);
         while (max > 0) {
             CServiceResult ip = {};
             if (!Get_(ip, wait)) {
                 return;
             }
             ips.push_back(ip);
             max--;
         }
     }
 
     void ResultMany(const std::vector<CServiceResult> &ips) {
         LOCK(cs);
         for (size_t i = 0; i < ips.size(); i++) {
             if (ips[i].fGood) {
                 Good_(ips[i].service, ips[i].nClientV, ips[i].strClientV,
                       ips[i].nHeight);
             } else {
                 Bad_(ips[i].service, ips[i].nBanTime);
             }
         }
     }
 
     void GetIPs(std::set<CNetAddr> &ips, uint64_t requestedFlags, uint32_t max,
                 const bool *nets) {
         LOCK(cs);
         GetIPs_(ips, requestedFlags, max, nets);
     }
 };
 
-#endif
+#endif // BITCOIN_SEEDER_DB_H
diff --git a/src/seeder/dns.h b/src/seeder/dns.h
index f51dd2195..34e56db3e 100644
--- a/src/seeder/dns.h
+++ b/src/seeder/dns.h
@@ -1,29 +1,29 @@
 #ifndef BITCOIN_SEEDER_DNS_H
 #define BITCOIN_SEEDER_DNS_H 1
 
 #include <cstdint>
 
 struct addr_t {
     int v;
     union {
         uint8_t v4[4];
         uint8_t v6[16];
     } data;
 };
 
 struct dns_opt_t {
     int port;
     int datattl;
     int nsttl;
     const char *host;
     const char *ns;
     const char *mbox;
     uint32_t (*cb)(void *opt, char *requested_hostname, addr_t *addr,
                    uint32_t max, uint32_t ipv4, uint32_t ipv6);
     // stats
     uint64_t nRequests;
 };
 
 int dnsserver(dns_opt_t *opt);
 
-#endif
+#endif // BITCOIN_SEEDER_DNS_H
diff --git a/src/seeder/strlcpy.h b/src/seeder/strlcpy.h
index 6cd3e5230..a2131ad19 100644
--- a/src/seeder/strlcpy.h
+++ b/src/seeder/strlcpy.h
@@ -1,80 +1,80 @@
 /*
  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #ifndef BITCOIN_SEEDER_STRLCPY_H
 #define BITCOIN_SEEDER_STRLCPY_H
 
 #include <cstdlib>
 #include <cstring>
 
 /*
  * Copy src to string dst of size siz.  At most siz-1 characters
  * will be copied.  Always NUL terminates (unless siz == 0).
  * Returns strlen(src); if retval >= siz, truncation occurred.
  */
 inline size_t strlcpy(char *dst, const char *src, size_t siz) {
     char *d = dst;
     const char *s = src;
     size_t n = siz;
 
     /* Copy as many bytes as will fit */
     if (n != 0) {
         while (--n != 0) {
             if ((*d++ = *s++) == '\0') break;
         }
     }
 
     /* Not enough room in dst, add NUL and traverse rest of src */
     if (n == 0) {
         if (siz != 0) *d = '\0'; /* NUL-terminate dst */
         while (*s++)
             ;
     }
 
     return (s - src - 1); /* count does not include NUL */
 }
 
 /*
  * Appends src to string dst of size siz (unlike strncat, siz is the
  * full size of dst, not space left).  At most siz-1 characters
  * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
  * If retval >= siz, truncation occurred.
  */
 inline size_t strlcat(char *dst, const char *src, size_t siz) {
     char *d = dst;
     const char *s = src;
     size_t n = siz;
     size_t dlen;
 
     /* Find the end of dst and adjust bytes left but don't go past end */
     while (n-- != 0 && *d != '\0')
         d++;
     dlen = d - dst;
     n = siz - dlen;
 
     if (n == 0) return (dlen + strlen(s));
     while (*s != '\0') {
         if (n != 1) {
             *d++ = *s;
             n--;
         }
         s++;
     }
     *d = '\0';
 
     return (dlen + (s - src)); /* count does not include NUL */
 }
-#endif
+#endif // BITCOIN_SEEDER_STRLCPY_H
diff --git a/src/seeder/util.h b/src/seeder/util.h
index 05dd26db2..0acda4b61 100644
--- a/src/seeder/util.h
+++ b/src/seeder/util.h
@@ -1,16 +1,16 @@
 #ifndef BITCOIN_SEEDER_UTIL_H
 #define BITCOIN_SEEDER_UTIL_H
 
 #include <ctime>
 
 #define BEGIN(a) ((char *)&(a))
 #define END(a) ((char *)&((&(a))[1]))
 
 static inline void Sleep(int nMilliSec) {
     struct timespec wa;
     wa.tv_sec = nMilliSec / 1000;
     wa.tv_nsec = (nMilliSec % 1000) * 1000000;
     nanosleep(&wa, nullptr);
 }
 
-#endif
+#endif // BITCOIN_SEEDER_UTIL_H
diff --git a/src/test/scriptnum10.h b/src/test/scriptnum10.h
index faa4e0573..bc27f4ad1 100644
--- a/src/test/scriptnum10.h
+++ b/src/test/scriptnum10.h
@@ -1,195 +1,195 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_TEST_SCRIPTNUM10_H
 #define BITCOIN_TEST_SCRIPTNUM10_H
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
 class scriptnum10_error : public std::runtime_error {
 public:
     explicit scriptnum10_error(const std::string &str)
         : std::runtime_error(str) {}
 };
 
 class CScriptNum10 {
     /**
      * The ScriptNum implementation from Bitcoin Core 0.10.0, for
      * cross-comparison.
      */
 public:
     explicit CScriptNum10(const int64_t &n) { m_value = n; }
 
     static const size_t nDefaultMaxNumSize = 4;
 
     explicit CScriptNum10(const std::vector<uint8_t> &vch, bool fRequireMinimal,
                           const size_t nMaxNumSize = nDefaultMaxNumSize) {
         if (vch.size() > nMaxNumSize) {
             throw scriptnum10_error("script number overflow");
         }
         if (fRequireMinimal && vch.size() > 0) {
             // Check that the number is encoded with the minimum possible number
             // of bytes.
             //
             // If the most-significant-byte - excluding the sign bit - is zero
             // then we're not minimal. Note how this test also rejects the
             // negative-zero encoding, 0x80.
             if ((vch.back() & 0x7f) == 0) {
                 // One exception: if there's more than one byte and the most
                 // significant bit of the second-most-significant-byte is set it
                 // would conflict with the sign bit. An example of this case is
                 // +-255, which encode to 0xff00 and 0xff80 respectively.
                 // (big-endian).
                 if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
                     throw scriptnum10_error(
                         "non-minimally encoded script number");
                 }
             }
         }
         m_value = set_vch(vch);
     }
 
     inline bool operator==(const int64_t &rhs) const { return m_value == rhs; }
     inline bool operator!=(const int64_t &rhs) const { return m_value != rhs; }
     inline bool operator<=(const int64_t &rhs) const { return m_value <= rhs; }
     inline bool operator<(const int64_t &rhs) const { return m_value < rhs; }
     inline bool operator>=(const int64_t &rhs) const { return m_value >= rhs; }
     inline bool operator>(const int64_t &rhs) const { return m_value > rhs; }
 
     inline bool operator==(const CScriptNum10 &rhs) const {
         return operator==(rhs.m_value);
     }
     inline bool operator!=(const CScriptNum10 &rhs) const {
         return operator!=(rhs.m_value);
     }
     inline bool operator<=(const CScriptNum10 &rhs) const {
         return operator<=(rhs.m_value);
     }
     inline bool operator<(const CScriptNum10 &rhs) const {
         return operator<(rhs.m_value);
     }
     inline bool operator>=(const CScriptNum10 &rhs) const {
         return operator>=(rhs.m_value);
     }
     inline bool operator>(const CScriptNum10 &rhs) const {
         return operator>(rhs.m_value);
     }
 
     inline CScriptNum10 operator+(const int64_t &rhs) const {
         return CScriptNum10(m_value + rhs);
     }
     inline CScriptNum10 operator-(const int64_t &rhs) const {
         return CScriptNum10(m_value - rhs);
     }
     inline CScriptNum10 operator+(const CScriptNum10 &rhs) const {
         return operator+(rhs.m_value);
     }
     inline CScriptNum10 operator-(const CScriptNum10 &rhs) const {
         return operator-(rhs.m_value);
     }
 
     inline CScriptNum10 &operator+=(const CScriptNum10 &rhs) {
         return operator+=(rhs.m_value);
     }
     inline CScriptNum10 &operator-=(const CScriptNum10 &rhs) {
         return operator-=(rhs.m_value);
     }
 
     inline CScriptNum10 operator-() const {
         assert(m_value != std::numeric_limits<int64_t>::min());
         return CScriptNum10(-m_value);
     }
 
     inline CScriptNum10 &operator=(const int64_t &rhs) {
         m_value = rhs;
         return *this;
     }
 
     inline CScriptNum10 &operator+=(const int64_t &rhs) {
         assert(
             rhs == 0 ||
             (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
             (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
         m_value += rhs;
         return *this;
     }
 
     inline CScriptNum10 &operator-=(const int64_t &rhs) {
         assert(
             rhs == 0 ||
             (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
             (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
         m_value -= rhs;
         return *this;
     }
 
     int getint() const {
         if (m_value > std::numeric_limits<int>::max())
             return std::numeric_limits<int>::max();
         else if (m_value < std::numeric_limits<int>::min())
             return std::numeric_limits<int>::min();
         return m_value;
     }
 
     std::vector<uint8_t> getvch() const { return serialize(m_value); }
 
     static std::vector<uint8_t> serialize(const int64_t &value) {
         if (value == 0) return std::vector<uint8_t>();
 
         std::vector<uint8_t> result;
         const bool neg = value < 0;
         uint64_t absvalue = neg ? -value : value;
 
         while (absvalue) {
             result.push_back(absvalue & 0xff);
             absvalue >>= 8;
         }
 
         //    - If the most significant byte is >= 0x80 and the value is
         //    positive, push a new zero-byte to make the significant byte < 0x80
         //    again.
 
         //    - If the most significant byte is >= 0x80 and the value is
         //    negative, push a new 0x80 byte that will be popped off when
         //    converting to an integral.
 
         //    - If the most significant byte is < 0x80 and the value is
         //    negative, add 0x80 to it, since it will be subtracted and
         //    interpreted as a negative when converting to an integral.
 
         if (result.back() & 0x80)
             result.push_back(neg ? 0x80 : 0);
         else if (neg)
             result.back() |= 0x80;
 
         return result;
     }
 
 private:
     static int64_t set_vch(const std::vector<uint8_t> &vch) {
         if (vch.empty()) return 0;
 
         int64_t result = 0;
         for (size_t i = 0; i != vch.size(); ++i)
             result |= static_cast<int64_t>(vch[i]) << 8 * i;
 
         // If the input vector's most significant byte is 0x80, remove it from
         // the result's msb and return a negative.
         if (vch.back() & 0x80)
             return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
 
         return result;
     }
 
     int64_t m_value;
 };
 
-#endif // BITCOIN_TEST_BIGNUM_H
+#endif // BITCOIN_TEST_SCRIPTNUM10_H
diff --git a/src/test/test_bitcoin.h b/src/test/test_bitcoin.h
index 7c76028cb..2155df6d2 100644
--- a/src/test/test_bitcoin.h
+++ b/src/test/test_bitcoin.h
@@ -1,165 +1,165 @@
 // Copyright (c) 2015-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_TEST_TEST_BITCOIN_H
 #define BITCOIN_TEST_TEST_BITCOIN_H
 
 #include <chainparamsbase.h>
 #include <fs.h>
 #include <key.h>
 #include <pubkey.h>
 #include <random.h>
 #include <scheduler.h>
 #include <txmempool.h>
 
 /**
  * Version of Boost::test prior to 1.64 have issues when dealing with nullptr_t.
  * In order to work around this, we ensure that the null pointers are typed in a
  * way that Boost will like better.
  *
  * TODO: Use nullptr directly once the minimum version of boost is 1.64 or more.
  */
 #define NULLPTR(T) static_cast<T *>(nullptr)
 
 /**
  * This global and the helpers that use it are not thread-safe.
  *
  * If thread-safety is needed, the global could be made thread_local (given
  * that thread_local is supported on all architectures we support) or a
  * per-thread instance could be used in the multi-threaded test.
  */
 extern FastRandomContext g_insecure_rand_ctx;
 
 static inline void SeedInsecureRand(bool deterministic = false) {
     g_insecure_rand_ctx = FastRandomContext(deterministic);
 }
 
 static inline uint32_t InsecureRand32() {
     return g_insecure_rand_ctx.rand32();
 }
 static inline uint256 InsecureRand256() {
     return g_insecure_rand_ctx.rand256();
 }
 static inline uint64_t InsecureRandBits(int bits) {
     return g_insecure_rand_ctx.randbits(bits);
 }
 static inline uint64_t InsecureRandRange(uint64_t range) {
     return g_insecure_rand_ctx.randrange(range);
 }
 static inline bool InsecureRandBool() {
     return g_insecure_rand_ctx.randbool();
 }
 
 /**
  * Basic testing setup.
  * This just configures logging and chain parameters.
  */
 struct BasicTestingSetup {
     ECCVerifyHandle globalVerifyHandle;
 
     explicit BasicTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~BasicTestingSetup();
 
     fs::path SetDataDir(const std::string &name);
 
 private:
     const fs::path m_path_root;
 };
 
 /**
  * Testing setup that configures a complete environment.
  * Included are data directory, coins database, script check threads setup.
  */
 class CConnman;
 class CNode;
 
 class PeerLogicValidation;
 struct TestingSetup : public BasicTestingSetup {
     boost::thread_group threadGroup;
     CScheduler scheduler;
 
     explicit TestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~TestingSetup();
 };
 
 class CBlock;
 class CMutableTransaction;
 class CScript;
 
 //
 // Testing fixture that pre-creates a
 // 100-block REGTEST-mode block chain
 //
 struct TestChain100Setup : public TestingSetup {
     TestChain100Setup();
 
     // Create a new block with just given transactions, coinbase paying to
     // scriptPubKey, and try to add it to the current chain.
     CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction> &txns,
                                  const CScript &scriptPubKey);
 
     ~TestChain100Setup();
 
     // For convenience, coinbase transactions.
     std::vector<CTransactionRef> m_coinbase_txns;
     // private/public key needed to spend coinbase transactions.
     CKey coinbaseKey;
 };
 
 class CTxMemPoolEntry;
 class CTxMemPool;
 
 struct TestMemPoolEntryHelper {
     // Default values
     Amount nFee;
     int64_t nTime;
     double dPriority;
     unsigned int nHeight;
     bool spendsCoinbase;
     unsigned int sigOpCost;
     LockPoints lp;
 
     TestMemPoolEntryHelper()
         : nFee(), nTime(0), dPriority(0.0), nHeight(1), spendsCoinbase(false),
           sigOpCost(4) {}
 
     CTxMemPoolEntry FromTx(const CMutableTransaction &tx,
                            CTxMemPool *pool = nullptr);
     CTxMemPoolEntry FromTx(const CTransactionRef &tx,
                            CTxMemPool *pool = nullptr);
 
     // Change the default value
     TestMemPoolEntryHelper &Fee(Amount _fee) {
         nFee = _fee;
         return *this;
     }
     TestMemPoolEntryHelper &Time(int64_t _time) {
         nTime = _time;
         return *this;
     }
     TestMemPoolEntryHelper &Priority(double _priority) {
         dPriority = _priority;
         return *this;
     }
     TestMemPoolEntryHelper &Height(unsigned int _height) {
         nHeight = _height;
         return *this;
     }
     TestMemPoolEntryHelper &SpendsCoinbase(bool _flag) {
         spendsCoinbase = _flag;
         return *this;
     }
     TestMemPoolEntryHelper &SigOpsCost(unsigned int _sigopsCost) {
         sigOpCost = _sigopsCost;
         return *this;
     }
 };
 
 // define an implicit conversion here so that uint256 may be used directly in
 // BOOST_CHECK_*
 std::ostream &operator<<(std::ostream &os, const uint256 &num);
 
-#endif
+#endif // BITCOIN_TEST_TEST_BITCOIN_H
diff --git a/src/torcontrol.h b/src/torcontrol.h
index f4bfa24c0..fb82e78a7 100644
--- a/src/torcontrol.h
+++ b/src/torcontrol.h
@@ -1,20 +1,20 @@
 // Copyright (c) 2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 /**
  * Functionality for communicating with Tor.
  */
 #ifndef BITCOIN_TORCONTROL_H
 #define BITCOIN_TORCONTROL_H
 
 #include <scheduler.h>
 
 extern const std::string DEFAULT_TOR_CONTROL;
 static const bool DEFAULT_LISTEN_ONION = true;
 
 void StartTorControl();
 void InterruptTorControl();
 void StopTorControl();
 
-#endif /* BITCOIN_TORCONTROL_H */
+#endif // BITCOIN_TORCONTROL_H
diff --git a/src/warnings.h b/src/warnings.h
index b1dc465c6..fab896bd5 100644
--- a/src/warnings.h
+++ b/src/warnings.h
@@ -1,27 +1,27 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WARNINGS_H
 #define BITCOIN_WARNINGS_H
 
 #include <cstdlib>
 #include <string>
 
 void SetMiscWarning(const std::string &strWarning);
 void SetfLargeWorkForkFound(bool flag);
 bool GetfLargeWorkForkFound();
 void SetfLargeWorkInvalidChainFound(bool flag);
 /**
  * Format a string that describes several potential problems detected by the
  * core.
  * strFor can have three values:
  * - "statusbar": get all warnings
  * - "gui": get all warnings, translated (where possible) for GUI
  * This function only returns the highest priority warning of the set selected
  * by strFor.
  */
 std::string GetWarnings(const std::string &strFor);
 
-#endif //  BITCOIN_WARNINGS_H
+#endif // BITCOIN_WARNINGS_H