diff --git a/src/base58.cpp b/src/base58.cpp
index df57f74b3..199e1586b 100644
--- a/src/base58.cpp
+++ b/src/base58.cpp
@@ -1,304 +1,304 @@
 // Copyright (c) 2014-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.
 
 #include <base58.h>
 
 #include <hash.h>
 #include <script/script.h>
 #include <uint256.h>
 #include <utilstrencodings.h>
 
 #include <boost/variant/apply_visitor.hpp>
 #include <boost/variant/static_visitor.hpp>
 
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <vector>
 
 /** All alphanumeric characters except for "0", "I", "O", and "l" */
 static const char *pszBase58 =
     "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
 bool DecodeBase58(const char *psz, std::vector<uint8_t> &vch) {
     // Skip leading spaces.
     while (*psz && IsSpace(*psz)) {
         psz++;
     }
     // Skip and count leading '1's.
     int zeroes = 0;
     int length = 0;
     while (*psz == '1') {
         zeroes++;
         psz++;
     }
     // Allocate enough space in big-endian base256 representation.
     // log(58) / log(256), rounded up.
     int size = strlen(psz) * 733 / 1000 + 1;
     std::vector<uint8_t> b256(size);
     // Process the characters.
     while (*psz && !IsSpace(*psz)) {
         // Decode base58 character
         const char *ch = strchr(pszBase58, *psz);
         if (ch == nullptr) {
             return false;
         }
         // Apply "b256 = b256 * 58 + ch".
         int carry = ch - pszBase58;
         int i = 0;
         for (std::vector<uint8_t>::reverse_iterator it = b256.rbegin();
              (carry != 0 || i < length) && (it != b256.rend()); ++it, ++i) {
             carry += 58 * (*it);
             *it = carry % 256;
             carry /= 256;
         }
         assert(carry == 0);
         length = i;
         psz++;
     }
     // Skip trailing spaces.
     while (IsSpace(*psz)) {
         psz++;
     }
     if (*psz != 0) {
         return false;
     }
     // Skip leading zeroes in b256.
     std::vector<uint8_t>::iterator it = b256.begin() + (size - length);
     while (it != b256.end() && *it == 0)
         it++;
     // Copy result into output vector.
     vch.reserve(zeroes + (b256.end() - it));
     vch.assign(zeroes, 0x00);
     while (it != b256.end()) {
         vch.push_back(*(it++));
     }
     return true;
 }
 
 std::string EncodeBase58(const uint8_t *pbegin, const uint8_t *pend) {
     // Skip & count leading zeroes.
     int zeroes = 0;
     int length = 0;
     while (pbegin != pend && *pbegin == 0) {
         pbegin++;
         zeroes++;
     }
     // Allocate enough space in big-endian base58 representation.
     // log(256) / log(58), rounded up.
     int size = (pend - pbegin) * 138 / 100 + 1;
     std::vector<uint8_t> b58(size);
     // Process the bytes.
     while (pbegin != pend) {
         int carry = *pbegin;
         int i = 0;
         // Apply "b58 = b58 * 256 + ch".
         for (std::vector<uint8_t>::reverse_iterator it = b58.rbegin();
              (carry != 0 || i < length) && (it != b58.rend()); it++, i++) {
             carry += 256 * (*it);
             *it = carry % 58;
             carry /= 58;
         }
 
         assert(carry == 0);
         length = i;
         pbegin++;
     }
     // Skip leading zeroes in base58 result.
     std::vector<uint8_t>::iterator it = b58.begin() + (size - length);
     while (it != b58.end() && *it == 0) {
         it++;
     }
     // Translate the result into a string.
     std::string str;
     str.reserve(zeroes + (b58.end() - it));
     str.assign(zeroes, '1');
     while (it != b58.end()) {
         str += pszBase58[*(it++)];
     }
     return str;
 }
 
 std::string EncodeBase58(const std::vector<uint8_t> &vch) {
-    return EncodeBase58(&vch[0], &vch[0] + vch.size());
+    return EncodeBase58(vch.data(), vch.data() + vch.size());
 }
 
 bool DecodeBase58(const std::string &str, std::vector<uint8_t> &vchRet) {
     return DecodeBase58(str.c_str(), vchRet);
 }
 
 std::string EncodeBase58Check(const std::vector<uint8_t> &vchIn) {
     // add 4-byte hash check to the end
     std::vector<uint8_t> vch(vchIn);
     uint256 hash = Hash(vch.begin(), vch.end());
     vch.insert(vch.end(), (uint8_t *)&hash, (uint8_t *)&hash + 4);
     return EncodeBase58(vch);
 }
 
 bool DecodeBase58Check(const char *psz, std::vector<uint8_t> &vchRet) {
     if (!DecodeBase58(psz, vchRet) || (vchRet.size() < 4)) {
         vchRet.clear();
         return false;
     }
     // re-calculate the checksum, ensure it matches the included 4-byte checksum
     uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);
     if (memcmp(&hash, &vchRet.end()[-4], 4) != 0) {
         vchRet.clear();
         return false;
     }
     vchRet.resize(vchRet.size() - 4);
     return true;
 }
 
 bool DecodeBase58Check(const std::string &str, std::vector<uint8_t> &vchRet) {
     return DecodeBase58Check(str.c_str(), vchRet);
 }
 
 CBase58Data::CBase58Data() {
     vchVersion.clear();
     vchData.clear();
 }
 
 void CBase58Data::SetData(const std::vector<uint8_t> &vchVersionIn,
                           const void *pdata, size_t nSize) {
     vchVersion = vchVersionIn;
     vchData.resize(nSize);
     if (!vchData.empty()) {
-        memcpy(&vchData[0], pdata, nSize);
+        memcpy(vchData.data(), pdata, nSize);
     }
 }
 
 void CBase58Data::SetData(const std::vector<uint8_t> &vchVersionIn,
                           const uint8_t *pbegin, const uint8_t *pend) {
     SetData(vchVersionIn, (void *)pbegin, pend - pbegin);
 }
 
 bool CBase58Data::SetString(const char *psz, unsigned int nVersionBytes) {
     std::vector<uint8_t> vchTemp;
     bool rc58 = DecodeBase58Check(psz, vchTemp);
     if ((!rc58) || (vchTemp.size() < nVersionBytes)) {
         vchData.clear();
         vchVersion.clear();
         return false;
     }
     vchVersion.assign(vchTemp.begin(), vchTemp.begin() + nVersionBytes);
     vchData.resize(vchTemp.size() - nVersionBytes);
     if (!vchData.empty()) {
-        memcpy(&vchData[0], &vchTemp[nVersionBytes], vchData.size());
+        memcpy(vchData.data(), vchTemp.data() + nVersionBytes, vchData.size());
     }
-    memory_cleanse(&vchTemp[0], vchTemp.size());
+    memory_cleanse(vchTemp.data(), vchTemp.size());
     return true;
 }
 
 bool CBase58Data::SetString(const std::string &str) {
     return SetString(str.c_str());
 }
 
 std::string CBase58Data::ToString() const {
     std::vector<uint8_t> vch = vchVersion;
     vch.insert(vch.end(), vchData.begin(), vchData.end());
     return EncodeBase58Check(vch);
 }
 
 int CBase58Data::CompareTo(const CBase58Data &b58) const {
     if (vchVersion < b58.vchVersion) return -1;
     if (vchVersion > b58.vchVersion) return 1;
     if (vchData < b58.vchData) return -1;
     if (vchData > b58.vchData) return 1;
     return 0;
 }
 
 namespace {
 class DestinationEncoder : public boost::static_visitor<std::string> {
 private:
     const CChainParams &m_params;
 
 public:
     explicit DestinationEncoder(const CChainParams &params)
         : m_params(params) {}
 
     std::string operator()(const CKeyID &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
     std::string operator()(const CScriptID &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
     std::string operator()(const CNoDestination &no) const { return ""; }
 };
 
 CTxDestination DecodeDestination(const std::string &str,
                                  const CChainParams &params) {
     std::vector<uint8_t> data;
     uint160 hash;
     if (!DecodeBase58Check(str, data)) {
         return CNoDestination();
     }
     // Base58Check decoding
     const std::vector<uint8_t> &pubkey_prefix =
         params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
     if (data.size() == 20 + pubkey_prefix.size() &&
         std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin())) {
         memcpy(hash.begin(), &data[pubkey_prefix.size()], 20);
         return CKeyID(hash);
     }
     const std::vector<uint8_t> &script_prefix =
         params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
     if (data.size() == 20 + script_prefix.size() &&
         std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) {
         memcpy(hash.begin(), &data[script_prefix.size()], 20);
         return CScriptID(hash);
     }
     return CNoDestination();
 }
 } // namespace
 
 void CBitcoinSecret::SetKey(const CKey &vchSecret) {
     assert(vchSecret.IsValid());
     SetData(Params().Base58Prefix(CChainParams::SECRET_KEY), vchSecret.begin(),
             vchSecret.size());
     if (vchSecret.IsCompressed()) vchData.push_back(1);
 }
 
 CKey CBitcoinSecret::GetKey() {
     CKey ret;
     assert(vchData.size() >= 32);
     ret.Set(vchData.begin(), vchData.begin() + 32,
             vchData.size() > 32 && vchData[32] == 1);
     return ret;
 }
 
 bool CBitcoinSecret::IsValid() const {
     bool fExpectedFormat =
         vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1);
     bool fCorrectVersion =
         vchVersion == Params().Base58Prefix(CChainParams::SECRET_KEY);
     return fExpectedFormat && fCorrectVersion;
 }
 
 bool CBitcoinSecret::SetString(const char *pszSecret) {
     return CBase58Data::SetString(pszSecret) && IsValid();
 }
 
 bool CBitcoinSecret::SetString(const std::string &strSecret) {
     return SetString(strSecret.c_str());
 }
 
 std::string EncodeLegacyAddr(const CTxDestination &dest,
                              const CChainParams &params) {
     return boost::apply_visitor(DestinationEncoder(params), dest);
 }
 
 CTxDestination DecodeLegacyAddr(const std::string &str,
                                 const CChainParams &params) {
     return DecodeDestination(str, params);
 }
diff --git a/src/base58.h b/src/base58.h
index 3ada1bdd0..bfa08b542 100644
--- a/src/base58.h
+++ b/src/base58.h
@@ -1,161 +1,161 @@
 // 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.
 
 /**
  * Why base-58 instead of standard base-64 encoding?
  * - Don't want 0OIl characters that look the same in some fonts and
  *      could be used to create visually identical looking data.
  * - A string with non-alphanumeric characters is not as easily accepted as
  * input.
  * - E-mail usually won't line-break if there's no punctuation to break at.
  * - Double-clicking selects the whole string as one word if it's all
  * alphanumeric.
  */
 #ifndef BITCOIN_BASE58_H
 #define BITCOIN_BASE58_H
 
 #include <chainparams.h>
 #include <key.h>
 #include <pubkey.h>
 #include <script/standard.h>
 #include <support/allocators/zeroafterfree.h>
 
 #include <string>
 #include <vector>
 
 /**
  * Encode a byte sequence as a base58-encoded string.
  * pbegin and pend cannot be nullptr, unless both are.
  */
 std::string EncodeBase58(const uint8_t *pbegin, const uint8_t *pend);
 
 /**
  * Encode a byte vector as a base58-encoded string
  */
 std::string EncodeBase58(const std::vector<uint8_t> &vch);
 
 /**
  * Decode a base58-encoded string (psz) into a byte vector (vchRet).
  * return true if decoding is successful.
  * psz cannot be nullptr.
  */
 bool DecodeBase58(const char *psz, std::vector<uint8_t> &vchRet);
 
 /**
  * Decode a base58-encoded string (str) into a byte vector (vchRet).
  * return true if decoding is successful.
  */
 bool DecodeBase58(const std::string &str, std::vector<uint8_t> &vchRet);
 
 /**
  * Encode a byte vector into a base58-encoded string, including checksum
  */
 std::string EncodeBase58Check(const std::vector<uint8_t> &vchIn);
 
 /**
  * Decode a base58-encoded string (psz) that includes a checksum into a byte
  * vector (vchRet), return true if decoding is successful
  */
 inline bool DecodeBase58Check(const char *psz, std::vector<uint8_t> &vchRet);
 
 /**
  * Decode a base58-encoded string (str) that includes a checksum into a byte
  * vector (vchRet), return true if decoding is successful
  */
 inline bool DecodeBase58Check(const std::string &str,
                               std::vector<uint8_t> &vchRet);
 
 /**
  * Base class for all base58-encoded data
  */
 class CBase58Data {
 protected:
     //! the version byte(s)
     std::vector<uint8_t> vchVersion;
 
     //! the actually encoded data
     typedef std::vector<uint8_t, zero_after_free_allocator<uint8_t>>
         vector_uchar;
     vector_uchar vchData;
 
     CBase58Data();
     void SetData(const std::vector<uint8_t> &vchVersionIn, const void *pdata,
                  size_t nSize);
     void SetData(const std::vector<uint8_t> &vchVersionIn,
                  const uint8_t *pbegin, const uint8_t *pend);
 
 public:
     bool SetString(const char *psz, unsigned int nVersionBytes = 1);
     bool SetString(const std::string &str);
     std::string ToString() const;
     int CompareTo(const CBase58Data &b58) const;
 
     bool operator==(const CBase58Data &b58) const {
         return CompareTo(b58) == 0;
     }
     bool operator<=(const CBase58Data &b58) const {
         return CompareTo(b58) <= 0;
     }
     bool operator>=(const CBase58Data &b58) const {
         return CompareTo(b58) >= 0;
     }
     bool operator<(const CBase58Data &b58) const { return CompareTo(b58) < 0; }
     bool operator>(const CBase58Data &b58) const { return CompareTo(b58) > 0; }
 };
 
 /**
  * A base58-encoded secret key
  */
 class CBitcoinSecret : public CBase58Data {
 public:
     void SetKey(const CKey &vchSecret);
     CKey GetKey();
     bool IsValid() const;
     bool SetString(const char *pszSecret);
     bool SetString(const std::string &strSecret);
 
     CBitcoinSecret(const CKey &vchSecret) { SetKey(vchSecret); }
     CBitcoinSecret() {}
 };
 
 template <typename K, int Size, CChainParams::Base58Type Type>
 class CBitcoinExtKeyBase : public CBase58Data {
 public:
     void SetKey(const K &key) {
         uint8_t vch[Size];
         key.Encode(vch);
         SetData(Params().Base58Prefix(Type), vch, vch + Size);
     }
 
     K GetKey() {
         K ret;
         if (vchData.size() == Size) {
             // If base58 encoded data does not hold an ext key, return a
             // !IsValid() key
-            ret.Decode(&vchData[0]);
+            ret.Decode(vchData.data());
         }
         return ret;
     }
 
     CBitcoinExtKeyBase(const K &key) { SetKey(key); }
 
     CBitcoinExtKeyBase(const std::string &strBase58c) {
         SetString(strBase58c.c_str(), Params().Base58Prefix(Type).size());
     }
 
     CBitcoinExtKeyBase() {}
 };
 
 typedef CBitcoinExtKeyBase<CExtKey, BIP32_EXTKEY_SIZE,
                            CChainParams::EXT_SECRET_KEY>
     CBitcoinExtKey;
 typedef CBitcoinExtKeyBase<CExtPubKey, BIP32_EXTKEY_SIZE,
                            CChainParams::EXT_PUBLIC_KEY>
     CBitcoinExtPubKey;
 
 std::string EncodeLegacyAddr(const CTxDestination &dest, const CChainParams &);
 CTxDestination DecodeLegacyAddr(const std::string &str, const CChainParams &);
 
 #endif // BITCOIN_BASE58_H
diff --git a/src/compressor.cpp b/src/compressor.cpp
index 9334a7751..dd2c07906 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -1,185 +1,185 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2014 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <compressor.h>
 
 #include <hash.h>
 #include <pubkey.h>
 #include <script/standard.h>
 
 bool CScriptCompressor::IsToKeyID(CKeyID &hash) const {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 &&
         script[2] == 20 && script[23] == OP_EQUALVERIFY &&
         script[24] == OP_CHECKSIG) {
         memcpy(&hash, &script[3], 20);
         return true;
     }
     return false;
 }
 
 bool CScriptCompressor::IsToScriptID(CScriptID &hash) const {
     if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20 &&
         script[22] == OP_EQUAL) {
         memcpy(&hash, &script[2], 20);
         return true;
     }
     return false;
 }
 
 bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const {
     if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG &&
         (script[1] == 0x02 || script[1] == 0x03)) {
         pubkey.Set(&script[1], &script[34]);
         return true;
     }
     if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG &&
         script[1] == 0x04) {
         pubkey.Set(&script[1], &script[66]);
         // if not fully valid, a case that would not be compressible
         return pubkey.IsFullyValid();
     }
     return false;
 }
 
 bool CScriptCompressor::Compress(std::vector<uint8_t> &out) const {
     CKeyID keyID;
     if (IsToKeyID(keyID)) {
         out.resize(21);
         out[0] = 0x00;
         memcpy(&out[1], &keyID, 20);
         return true;
     }
     CScriptID scriptID;
     if (IsToScriptID(scriptID)) {
         out.resize(21);
         out[0] = 0x01;
         memcpy(&out[1], &scriptID, 20);
         return true;
     }
     CPubKey pubkey;
     if (IsToPubKey(pubkey)) {
         out.resize(33);
         memcpy(&out[1], &pubkey[1], 32);
         if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
             out[0] = pubkey[0];
             return true;
         } else if (pubkey[0] == 0x04) {
             out[0] = 0x04 | (pubkey[64] & 0x01);
             return true;
         }
     }
     return false;
 }
 
 unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const {
     if (nSize == 0 || nSize == 1) {
         return 20;
     }
     if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5) {
         return 32;
     }
     return 0;
 }
 
 bool CScriptCompressor::Decompress(unsigned int nSize,
                                    const std::vector<uint8_t> &in) {
     switch (nSize) {
         case 0x00:
             script.resize(25);
             script[0] = OP_DUP;
             script[1] = OP_HASH160;
             script[2] = 20;
-            memcpy(&script[3], &in[0], 20);
+            memcpy(&script[3], in.data(), 20);
             script[23] = OP_EQUALVERIFY;
             script[24] = OP_CHECKSIG;
             return true;
         case 0x01:
             script.resize(23);
             script[0] = OP_HASH160;
             script[1] = 20;
-            memcpy(&script[2], &in[0], 20);
+            memcpy(&script[2], in.data(), 20);
             script[22] = OP_EQUAL;
             return true;
         case 0x02:
         case 0x03:
             script.resize(35);
             script[0] = 33;
             script[1] = nSize;
-            memcpy(&script[2], &in[0], 32);
+            memcpy(&script[2], in.data(), 32);
             script[34] = OP_CHECKSIG;
             return true;
         case 0x04:
         case 0x05:
             uint8_t vch[33] = {};
             vch[0] = nSize - 2;
-            memcpy(&vch[1], &in[0], 32);
+            memcpy(&vch[1], in.data(), 32);
             CPubKey pubkey(&vch[0], &vch[33]);
             if (!pubkey.Decompress()) return false;
             assert(pubkey.size() == 65);
             script.resize(67);
             script[0] = 65;
             memcpy(&script[1], pubkey.begin(), 65);
             script[66] = OP_CHECKSIG;
             return true;
     }
     return false;
 }
 
 // Amount compression:
 // * If the amount is 0, output 0
 // * first, divide the amount (in base units) by the largest power of 10
 // possible; call the exponent e (e is max 9)
 // * if e<9, the last digit of the resulting number cannot be 0; store it as d,
 // and drop it (divide by 10)
 //   * call the result n
 //   * output 1 + 10*(9*n + d - 1) + e
 // * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n
 // - 1) + 9
 // (this is decodable, as d is in [1-9] and e is in [0-9])
 uint64_t CTxOutCompressor::CompressAmount(Amount amt) {
     uint64_t n = amt / SATOSHI;
     if (n == 0) {
         return 0;
     }
     int e = 0;
     while (((n % 10) == 0) && e < 9) {
         n /= 10;
         e++;
     }
     if (e < 9) {
         int d = (n % 10);
         assert(d >= 1 && d <= 9);
         n /= 10;
         return 1 + (n * 9 + d - 1) * 10 + e;
     } else {
         return 1 + (n - 1) * 10 + 9;
     }
 }
 
 Amount CTxOutCompressor::DecompressAmount(uint64_t x) {
     // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
     if (x == 0) {
         return Amount::zero();
     }
     x--;
     // x = 10*(9*n + d - 1) + e
     int e = x % 10;
     x /= 10;
     uint64_t n = 0;
     if (e < 9) {
         // x = 9*n + d - 1
         int d = (x % 9) + 1;
         x /= 9;
         // x = n
         n = x * 10 + d;
     } else {
         n = x + 1;
     }
     while (e) {
         n *= 10;
         e--;
     }
     return int64_t(n) * SATOSHI;
 }
diff --git a/src/hash.cpp b/src/hash.cpp
index b91281fe0..09a8f09b4 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,88 +1,86 @@
 // Copyright (c) 2013-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.
 
 #include <hash.h>
 
 #include <crypto/common.h>
 #include <crypto/hmac_sha512.h>
 #include <pubkey.h>
 
 inline uint32_t ROTL32(uint32_t x, int8_t r) {
     return (x << r) | (x >> (32 - r));
 }
 
 uint32_t MurmurHash3(uint32_t nHashSeed,
                      const std::vector<uint8_t> &vDataToHash) {
     // The following is MurmurHash3 (x86_32), see
     // http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
     uint32_t h1 = nHashSeed;
-    if (vDataToHash.size() > 0) {
-        const uint32_t c1 = 0xcc9e2d51;
-        const uint32_t c2 = 0x1b873593;
+    const uint32_t c1 = 0xcc9e2d51;
+    const uint32_t c2 = 0x1b873593;
 
-        const int nblocks = vDataToHash.size() / 4;
+    const int nblocks = vDataToHash.size() / 4;
 
-        //----------
-        // body
-        const uint8_t *blocks = &vDataToHash[0] + nblocks * 4;
+    //----------
+    // body
+    const uint8_t *blocks = vDataToHash.data();
 
-        for (int i = -nblocks; i; i++) {
-            uint32_t k1 = ReadLE32(blocks + i * 4);
+    for (int i = 0; i < nblocks; ++i) {
+        uint32_t k1 = ReadLE32(blocks + i * 4);
 
-            k1 *= c1;
-            k1 = ROTL32(k1, 15);
-            k1 *= c2;
+        k1 *= c1;
+        k1 = ROTL32(k1, 15);
+        k1 *= c2;
 
-            h1 ^= k1;
-            h1 = ROTL32(h1, 13);
-            h1 = h1 * 5 + 0xe6546b64;
-        }
+        h1 ^= k1;
+        h1 = ROTL32(h1, 13);
+        h1 = h1 * 5 + 0xe6546b64;
+    }
 
-        //----------
-        // tail
-        const uint8_t *tail = (const uint8_t *)(&vDataToHash[0] + nblocks * 4);
+    //----------
+    // tail
+    const uint8_t *tail = vDataToHash.data() + nblocks * 4;
 
-        uint32_t k1 = 0;
+    uint32_t k1 = 0;
 
-        switch (vDataToHash.size() & 3) {
-            case 3:
-                k1 ^= tail[2] << 16;
-            // FALLTHROUGH
-            case 2:
-                k1 ^= tail[1] << 8;
-            // FALLTHROUGH
-            case 1:
-                k1 ^= tail[0];
-                k1 *= c1;
-                k1 = ROTL32(k1, 15);
-                k1 *= c2;
-                h1 ^= k1;
-        }
+    switch (vDataToHash.size() & 3) {
+        case 3:
+            k1 ^= tail[2] << 16;
+        // FALLTHROUGH
+        case 2:
+            k1 ^= tail[1] << 8;
+        // FALLTHROUGH
+        case 1:
+            k1 ^= tail[0];
+            k1 *= c1;
+            k1 = ROTL32(k1, 15);
+            k1 *= c2;
+            h1 ^= k1;
     }
 
     //----------
     // finalization
     h1 ^= vDataToHash.size();
     h1 ^= h1 >> 16;
     h1 *= 0x85ebca6b;
     h1 ^= h1 >> 13;
     h1 *= 0xc2b2ae35;
     h1 ^= h1 >> 16;
 
     return h1;
 }
 
 void BIP32Hash(const ChainCode &chainCode, uint32_t nChild, uint8_t header,
                const uint8_t data[32], uint8_t output[64]) {
     uint8_t num[4];
     num[0] = (nChild >> 24) & 0xFF;
     num[1] = (nChild >> 16) & 0xFF;
     num[2] = (nChild >> 8) & 0xFF;
     num[3] = (nChild >> 0) & 0xFF;
     CHMAC_SHA512(chainCode.begin(), chainCode.size())
         .Write(&header, 1)
         .Write(data, 32)
         .Write(num, 4)
         .Finalize(output);
 }
diff --git a/src/key.cpp b/src/key.cpp
index 2d473b4b7..9bd1dd053 100644
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -1,383 +1,383 @@
 // 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.
 
 #include <key.h>
 
 #include <arith_uint256.h>
 #include <crypto/common.h>
 #include <crypto/hmac_sha512.h>
 #include <pubkey.h>
 #include <random.h>
 
 #include <secp256k1.h>
 #include <secp256k1_recovery.h>
 #include <secp256k1_schnorr.h>
 
 static secp256k1_context *secp256k1_context_sign = nullptr;
 
 /**
  * These functions are taken from the libsecp256k1 distribution and are very
  * ugly.
  */
 static int ec_privkey_import_der(const secp256k1_context *ctx, uint8_t *out32,
                                  const uint8_t *privkey, size_t privkeylen) {
     const uint8_t *end = privkey + privkeylen;
     int lenb = 0;
     int len = 0;
     memset(out32, 0, 32);
     /* sequence header */
     if (end < privkey + 1 || *privkey != 0x30) {
         return 0;
     }
     privkey++;
     /* sequence length constructor */
     if (end < privkey + 1 || !(*privkey & 0x80)) {
         return 0;
     }
     lenb = *privkey & ~0x80;
     privkey++;
     if (lenb < 1 || lenb > 2) {
         return 0;
     }
     if (end < privkey + lenb) {
         return 0;
     }
     /* sequence length */
     len = privkey[lenb - 1] | (lenb > 1 ? privkey[lenb - 2] << 8 : 0);
     privkey += lenb;
     if (end < privkey + len) {
         return 0;
     }
     /* sequence element 0: version number (=1) */
     if (end < privkey + 3 || privkey[0] != 0x02 || privkey[1] != 0x01 ||
         privkey[2] != 0x01) {
         return 0;
     }
     privkey += 3;
     /* sequence element 1: octet string, up to 32 bytes */
     if (end < privkey + 2 || privkey[0] != 0x04 || privkey[1] > 0x20 ||
         end < privkey + 2 + privkey[1]) {
         return 0;
     }
     memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
     if (!secp256k1_ec_seckey_verify(ctx, out32)) {
         memset(out32, 0, 32);
         return 0;
     }
     return 1;
 }
 
 static int ec_privkey_export_der(const secp256k1_context *ctx, uint8_t *privkey,
                                  size_t *privkeylen, const uint8_t *key32,
                                  int compressed) {
     secp256k1_pubkey pubkey;
     size_t pubkeylen = 0;
     if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
         *privkeylen = 0;
         return 0;
     }
 
     if (compressed) {
         static const uint8_t begin[] = {0x30, 0x81, 0xD3, 0x02,
                                         0x01, 0x01, 0x04, 0x20};
         static const uint8_t middle[] = {
             0xA0, 0x81, 0x85, 0x30, 0x81, 0x82, 0x02, 0x01, 0x01, 0x30, 0x2C,
             0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x01, 0x01, 0x02, 0x21,
             0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFC, 0x2F,
             0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x21, 0x02,
             0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC, 0x55, 0xA0, 0x62,
             0x95, 0xCE, 0x87, 0x0B, 0x07, 0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE,
             0x28, 0xD9, 0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17, 0x98, 0x02,
             0x21, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC, 0xE6,
             0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41,
             0x41, 0x02, 0x01, 0x01, 0xA1, 0x24, 0x03, 0x22, 0x00};
         uint8_t *ptr = privkey;
         memcpy(ptr, begin, sizeof(begin));
         ptr += sizeof(begin);
         memcpy(ptr, key32, 32);
         ptr += 32;
         memcpy(ptr, middle, sizeof(middle));
         ptr += sizeof(middle);
         pubkeylen = 33;
         secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey,
                                       SECP256K1_EC_COMPRESSED);
         ptr += pubkeylen;
         *privkeylen = ptr - privkey;
     } else {
         static const uint8_t begin[] = {0x30, 0x82, 0x01, 0x13, 0x02,
                                         0x01, 0x01, 0x04, 0x20};
         static const uint8_t middle[] = {
             0xA0, 0x81, 0xA5, 0x30, 0x81, 0xA2, 0x02, 0x01, 0x01, 0x30, 0x2C,
             0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x01, 0x01, 0x02, 0x21,
             0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFC, 0x2F,
             0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x41, 0x04,
             0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC, 0x55, 0xA0, 0x62,
             0x95, 0xCE, 0x87, 0x0B, 0x07, 0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE,
             0x28, 0xD9, 0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17, 0x98, 0x48,
             0x3A, 0xDA, 0x77, 0x26, 0xA3, 0xC4, 0x65, 0x5D, 0xA4, 0xFB, 0xFC,
             0x0E, 0x11, 0x08, 0xA8, 0xFD, 0x17, 0xB4, 0x48, 0xA6, 0x85, 0x54,
             0x19, 0x9C, 0x47, 0xD0, 0x8F, 0xFB, 0x10, 0xD4, 0xB8, 0x02, 0x21,
             0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF,
             0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41,
             0x02, 0x01, 0x01, 0xA1, 0x44, 0x03, 0x42, 0x00};
         uint8_t *ptr = privkey;
         memcpy(ptr, begin, sizeof(begin));
         ptr += sizeof(begin);
         memcpy(ptr, key32, 32);
         ptr += 32;
         memcpy(ptr, middle, sizeof(middle));
         ptr += sizeof(middle);
         pubkeylen = 65;
         secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey,
                                       SECP256K1_EC_UNCOMPRESSED);
         ptr += pubkeylen;
         *privkeylen = ptr - privkey;
     }
     return 1;
 }
 
 bool CKey::Check(const uint8_t *vch) {
     return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
 }
 
 void CKey::MakeNewKey(bool fCompressedIn) {
     do {
         GetStrongRandBytes(keydata.data(), keydata.size());
     } while (!Check(keydata.data()));
     fValid = true;
     fCompressed = fCompressedIn;
 }
 
 CPrivKey CKey::GetPrivKey() const {
     assert(fValid);
     CPrivKey privkey;
     int ret;
     size_t privkeylen;
     privkey.resize(279);
     privkeylen = 279;
     ret = ec_privkey_export_der(
-        secp256k1_context_sign, (uint8_t *)&privkey[0], &privkeylen, begin(),
+        secp256k1_context_sign, (uint8_t *)privkey.data(), &privkeylen, begin(),
         fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
     assert(ret);
     privkey.resize(privkeylen);
     return privkey;
 }
 
 CPubKey CKey::GetPubKey() const {
     assert(fValid);
     secp256k1_pubkey pubkey;
     size_t clen = 65;
     CPubKey result;
     int ret =
         secp256k1_ec_pubkey_create(secp256k1_context_sign, &pubkey, begin());
     assert(ret);
     secp256k1_ec_pubkey_serialize(
         secp256k1_context_sign, (uint8_t *)result.begin(), &clen, &pubkey,
         fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
     assert(result.size() == clen);
     assert(result.IsValid());
     return result;
 }
 
 bool CKey::SignECDSA(const uint256 &hash, std::vector<uint8_t> &vchSig,
                      uint32_t test_case) const {
     if (!fValid) {
         return false;
     }
     vchSig.resize(72);
     size_t nSigLen = 72;
     uint8_t extra_entropy[32] = {0};
     WriteLE32(extra_entropy, test_case);
     secp256k1_ecdsa_signature sig;
     int ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(),
                                    begin(), secp256k1_nonce_function_rfc6979,
                                    test_case ? extra_entropy : nullptr);
     assert(ret);
     secp256k1_ecdsa_signature_serialize_der(
-        secp256k1_context_sign, (uint8_t *)&vchSig[0], &nSigLen, &sig);
+        secp256k1_context_sign, (uint8_t *)vchSig.data(), &nSigLen, &sig);
     vchSig.resize(nSigLen);
     return true;
 }
 
 bool CKey::SignSchnorr(const uint256 &hash, std::vector<uint8_t> &vchSig,
                        uint32_t test_case) const {
     if (!fValid) {
         return false;
     }
     vchSig.resize(64);
     uint8_t extra_entropy[32] = {0};
     WriteLE32(extra_entropy, test_case);
 
     int ret = secp256k1_schnorr_sign(
         secp256k1_context_sign, &vchSig[0], hash.begin(), begin(),
         secp256k1_nonce_function_rfc6979, test_case ? extra_entropy : nullptr);
     assert(ret);
     return true;
 }
 
 bool CKey::VerifyPubKey(const CPubKey &pubkey) const {
     if (pubkey.IsCompressed() != fCompressed) {
         return false;
     }
     uint8_t rnd[8];
     std::string str = "Bitcoin key verification\n";
     GetRandBytes(rnd, sizeof(rnd));
     uint256 hash;
     CHash256()
         .Write((uint8_t *)str.data(), str.size())
         .Write(rnd, sizeof(rnd))
         .Finalize(hash.begin());
     std::vector<uint8_t> vchSig;
     SignECDSA(hash, vchSig);
     return pubkey.VerifyECDSA(hash, vchSig);
 }
 
 bool CKey::SignCompact(const uint256 &hash,
                        std::vector<uint8_t> &vchSig) const {
     if (!fValid) {
         return false;
     }
     vchSig.resize(65);
     int rec = -1;
     secp256k1_ecdsa_recoverable_signature sig;
     int ret = secp256k1_ecdsa_sign_recoverable(
         secp256k1_context_sign, &sig, hash.begin(), begin(),
         secp256k1_nonce_function_rfc6979, nullptr);
     assert(ret);
     secp256k1_ecdsa_recoverable_signature_serialize_compact(
         secp256k1_context_sign, (uint8_t *)&vchSig[1], &rec, &sig);
     assert(ret);
     assert(rec != -1);
     vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
     return true;
 }
 
 bool CKey::Load(CPrivKey &privkey, CPubKey &vchPubKey,
                 bool fSkipCheck = false) {
     if (!ec_privkey_import_der(secp256k1_context_sign, (uint8_t *)begin(),
-                               &privkey[0], privkey.size()))
+                               privkey.data(), privkey.size()))
         return false;
     fCompressed = vchPubKey.IsCompressed();
     fValid = true;
 
     if (fSkipCheck) {
         return true;
     }
 
     return VerifyPubKey(vchPubKey);
 }
 
 bool CKey::Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild,
                   const ChainCode &cc) const {
     assert(IsValid());
     assert(IsCompressed());
     std::vector<uint8_t, secure_allocator<uint8_t>> vout(64);
     if ((nChild >> 31) == 0) {
         CPubKey pubkey = GetPubKey();
         assert(pubkey.begin() + 33 == pubkey.end());
         BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin() + 1, vout.data());
     } else {
         assert(begin() + 32 == end());
         BIP32Hash(cc, nChild, 0, begin(), vout.data());
     }
     memcpy(ccChild.begin(), vout.data() + 32, 32);
     memcpy((uint8_t *)keyChild.begin(), begin(), 32);
     bool ret = secp256k1_ec_privkey_tweak_add(
         secp256k1_context_sign, (uint8_t *)keyChild.begin(), vout.data());
     keyChild.fCompressed = true;
     keyChild.fValid = ret;
     return ret;
 }
 
 bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
     out.nDepth = nDepth + 1;
     CKeyID id = key.GetPubKey().GetID();
     memcpy(&out.vchFingerprint[0], &id, 4);
     out.nChild = _nChild;
     return key.Derive(out.key, out.chaincode, _nChild, chaincode);
 }
 
 void CExtKey::SetMaster(const uint8_t *seed, unsigned int nSeedLen) {
     static const uint8_t hashkey[] = {'B', 'i', 't', 'c', 'o', 'i',
                                       'n', ' ', 's', 'e', 'e', 'd'};
     std::vector<uint8_t, secure_allocator<uint8_t>> vout(64);
     CHMAC_SHA512(hashkey, sizeof(hashkey))
         .Write(seed, nSeedLen)
         .Finalize(vout.data());
-    key.Set(&vout[0], &vout[32], true);
-    memcpy(chaincode.begin(), &vout[32], 32);
+    key.Set(vout.data(), vout.data() + 32, true);
+    memcpy(chaincode.begin(), vout.data() + 32, 32);
     nDepth = 0;
     nChild = 0;
     memset(vchFingerprint, 0, sizeof(vchFingerprint));
 }
 
 CExtPubKey CExtKey::Neuter() const {
     CExtPubKey ret;
     ret.nDepth = nDepth;
     memcpy(&ret.vchFingerprint[0], &vchFingerprint[0], 4);
     ret.nChild = nChild;
     ret.pubkey = key.GetPubKey();
     ret.chaincode = chaincode;
     return ret;
 }
 
 void CExtKey::Encode(uint8_t code[BIP32_EXTKEY_SIZE]) const {
     code[0] = nDepth;
     memcpy(code + 1, vchFingerprint, 4);
     code[5] = (nChild >> 24) & 0xFF;
     code[6] = (nChild >> 16) & 0xFF;
     code[7] = (nChild >> 8) & 0xFF;
     code[8] = (nChild >> 0) & 0xFF;
     memcpy(code + 9, chaincode.begin(), 32);
     code[41] = 0;
     assert(key.size() == 32);
     memcpy(code + 42, key.begin(), 32);
 }
 
 void CExtKey::Decode(const uint8_t code[BIP32_EXTKEY_SIZE]) {
     nDepth = code[0];
     memcpy(vchFingerprint, code + 1, 4);
     nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
     memcpy(chaincode.begin(), code + 9, 32);
     key.Set(code + 42, code + BIP32_EXTKEY_SIZE, true);
 }
 
 bool ECC_InitSanityCheck() {
     CKey key;
     key.MakeNewKey(true);
     CPubKey pubkey = key.GetPubKey();
     return key.VerifyPubKey(pubkey);
 }
 
 void ECC_Start() {
     assert(secp256k1_context_sign == nullptr);
 
     secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
     assert(ctx != nullptr);
 
     {
         // Pass in a random blinding seed to the secp256k1 context.
         std::vector<uint8_t, secure_allocator<uint8_t>> vseed(32);
         GetRandBytes(vseed.data(), 32);
         bool ret = secp256k1_context_randomize(ctx, vseed.data());
         assert(ret);
     }
 
     secp256k1_context_sign = ctx;
 }
 
 void ECC_Stop() {
     secp256k1_context *ctx = secp256k1_context_sign;
     secp256k1_context_sign = nullptr;
 
     if (ctx) {
         secp256k1_context_destroy(ctx);
     }
 }
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
index 5a3cbb63e..5c2a323d5 100644
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -1,736 +1,736 @@
 // 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.
 
 #ifdef HAVE_CONFIG_H
 #include <config/bitcoin-config.h>
 #endif
 
 #include <hash.h>
 #include <netaddress.h>
 #include <tinyformat.h>
 #include <utilstrencodings.h>
 
 static const uint8_t pchIPv4[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};
 static const uint8_t pchOnionCat[] = {0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43};
 
 // 0xFD + sha256("bitcoin")[0:5]
 static const uint8_t g_internal_prefix[] = {0xFD, 0x6B, 0x88, 0xC0, 0x87, 0x24};
 
 CNetAddr::CNetAddr() {
     memset(ip, 0, sizeof(ip));
     scopeId = 0;
 }
 
 void CNetAddr::SetIP(const CNetAddr &ipIn) {
     memcpy(ip, ipIn.ip, sizeof(ip));
 }
 
 void CNetAddr::SetRaw(Network network, const uint8_t *ip_in) {
     switch (network) {
         case NET_IPV4:
             memcpy(ip, pchIPv4, 12);
             memcpy(ip + 12, ip_in, 4);
             break;
         case NET_IPV6:
             memcpy(ip, ip_in, 16);
             break;
         default:
             assert(!"invalid network");
     }
 }
 
 bool CNetAddr::SetInternal(const std::string &name) {
     if (name.empty()) {
         return false;
     }
     uint8_t hash[32] = {};
     CSHA256().Write((const uint8_t *)name.data(), name.size()).Finalize(hash);
     memcpy(ip, g_internal_prefix, sizeof(g_internal_prefix));
     memcpy(ip + sizeof(g_internal_prefix), hash,
            sizeof(ip) - sizeof(g_internal_prefix));
     return true;
 }
 
 bool CNetAddr::SetSpecial(const std::string &strName) {
     if (strName.size() > 6 &&
         strName.substr(strName.size() - 6, 6) == ".onion") {
         std::vector<uint8_t> vchAddr =
             DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
         if (vchAddr.size() != 16 - sizeof(pchOnionCat)) {
             return false;
         }
         memcpy(ip, pchOnionCat, sizeof(pchOnionCat));
         for (unsigned int i = 0; i < 16 - sizeof(pchOnionCat); i++) {
             ip[i + sizeof(pchOnionCat)] = vchAddr[i];
         }
         return true;
     }
     return false;
 }
 
 CNetAddr::CNetAddr(const struct in_addr &ipv4Addr) {
     SetRaw(NET_IPV4, (const uint8_t *)&ipv4Addr);
 }
 
 CNetAddr::CNetAddr(const struct in6_addr &ipv6Addr, const uint32_t scope) {
     SetRaw(NET_IPV6, (const uint8_t *)&ipv6Addr);
     scopeId = scope;
 }
 
 unsigned int CNetAddr::GetByte(int n) const {
     return ip[15 - n];
 }
 
 bool CNetAddr::IsIPv4() const {
     return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0);
 }
 
 bool CNetAddr::IsIPv6() const {
     return !IsIPv4() && !IsTor() && !IsInternal();
 }
 
 bool CNetAddr::IsRFC1918() const {
     return IsIPv4() &&
            (GetByte(3) == 10 || (GetByte(3) == 192 && GetByte(2) == 168) ||
             (GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31)));
 }
 
 bool CNetAddr::IsRFC2544() const {
     return IsIPv4() && GetByte(3) == 198 &&
            (GetByte(2) == 18 || GetByte(2) == 19);
 }
 
 bool CNetAddr::IsRFC3927() const {
     return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);
 }
 
 bool CNetAddr::IsRFC6598() const {
     return IsIPv4() && GetByte(3) == 100 && GetByte(2) >= 64 &&
            GetByte(2) <= 127;
 }
 
 bool CNetAddr::IsRFC5737() const {
     return IsIPv4() &&
            ((GetByte(3) == 192 && GetByte(2) == 0 && GetByte(1) == 2) ||
             (GetByte(3) == 198 && GetByte(2) == 51 && GetByte(1) == 100) ||
             (GetByte(3) == 203 && GetByte(2) == 0 && GetByte(1) == 113));
 }
 
 bool CNetAddr::IsRFC3849() const {
     return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D &&
            GetByte(12) == 0xB8;
 }
 
 bool CNetAddr::IsRFC3964() const {
     return (GetByte(15) == 0x20 && GetByte(14) == 0x02);
 }
 
 bool CNetAddr::IsRFC6052() const {
     static const uint8_t pchRFC6052[] = {0, 0x64, 0xFF, 0x9B, 0, 0,
                                          0, 0,    0,    0,    0, 0};
     return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0);
 }
 
 bool CNetAddr::IsRFC4380() const {
     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 &&
             GetByte(12) == 0);
 }
 
 bool CNetAddr::IsRFC4862() const {
     static const uint8_t pchRFC4862[] = {0xFE, 0x80, 0, 0, 0, 0, 0, 0};
     return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0);
 }
 
 bool CNetAddr::IsRFC4193() const {
     return ((GetByte(15) & 0xFE) == 0xFC);
 }
 
 bool CNetAddr::IsRFC6145() const {
     static const uint8_t pchRFC6145[] = {0, 0, 0,    0,    0, 0,
                                          0, 0, 0xFF, 0xFF, 0, 0};
     return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0);
 }
 
 bool CNetAddr::IsRFC4843() const {
     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 &&
             (GetByte(12) & 0xF0) == 0x10);
 }
 
 bool CNetAddr::IsTor() const {
     return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);
 }
 
 bool CNetAddr::IsLocal() const {
     // IPv4 loopback
     if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0)) return true;
 
     // IPv6 loopback (::1/128)
     static const uint8_t pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 1};
     if (memcmp(ip, pchLocal, 16) == 0) return true;
 
     return false;
 }
 
 bool CNetAddr::IsValid() const {
     // Cleanup 3-byte shifted addresses caused by garbage in size field of addr
     // messages from versions before 0.2.9 checksum.
     // Two consecutive addr messages look like this:
     // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26
     // addr26 addr26... so if the first length field is garbled, it reads the
     // second batch of addr misaligned by 3 bytes.
     if (memcmp(ip, pchIPv4 + 3, sizeof(pchIPv4) - 3) == 0) {
         return false;
     }
 
     // unspecified IPv6 address (::/128)
     uint8_t ipNone6[16] = {};
     if (memcmp(ip, ipNone6, 16) == 0) {
         return false;
     }
 
     // documentation IPv6 address
     if (IsRFC3849()) {
         return false;
     }
 
     if (IsInternal()) {
         return false;
     }
 
     if (IsIPv4()) {
         // INADDR_NONE
         uint32_t ipNone = INADDR_NONE;
         if (memcmp(ip + 12, &ipNone, 4) == 0) {
             return false;
         }
 
         // 0
         ipNone = 0;
         if (memcmp(ip + 12, &ipNone, 4) == 0) {
             return false;
         }
     }
 
     return true;
 }
 
 bool CNetAddr::IsRoutable() const {
     return IsValid() &&
            !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() ||
              IsRFC6598() || IsRFC5737() || (IsRFC4193() && !IsTor()) ||
              IsRFC4843() || IsLocal() || IsInternal());
 }
 
 bool CNetAddr::IsInternal() const {
     return memcmp(ip, g_internal_prefix, sizeof(g_internal_prefix)) == 0;
 }
 
 enum Network CNetAddr::GetNetwork() const {
     if (IsInternal()) {
         return NET_INTERNAL;
     }
 
     if (!IsRoutable()) {
         return NET_UNROUTABLE;
     }
 
     if (IsIPv4()) {
         return NET_IPV4;
     }
 
     if (IsTor()) {
         return NET_ONION;
     }
 
     return NET_IPV6;
 }
 
 std::string CNetAddr::ToStringIP() const {
     if (IsTor()) {
         return EncodeBase32(&ip[6], 10) + ".onion";
     }
     if (IsInternal()) {
         return EncodeBase32(ip + sizeof(g_internal_prefix),
                             sizeof(ip) - sizeof(g_internal_prefix)) +
                ".internal";
     }
     CService serv(*this, 0);
     struct sockaddr_storage sockaddr;
     socklen_t socklen = sizeof(sockaddr);
     if (serv.GetSockAddr((struct sockaddr *)&sockaddr, &socklen)) {
         char name[1025] = "";
         if (!getnameinfo((const struct sockaddr *)&sockaddr, socklen, name,
                          sizeof(name), nullptr, 0, NI_NUMERICHOST)) {
             return std::string(name);
         }
     }
     if (IsIPv4()) {
         return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1),
                          GetByte(0));
     }
 
     return strprintf("%x:%x:%x:%x:%x:%x:%x:%x", GetByte(15) << 8 | GetByte(14),
                      GetByte(13) << 8 | GetByte(12),
                      GetByte(11) << 8 | GetByte(10),
                      GetByte(9) << 8 | GetByte(8), GetByte(7) << 8 | GetByte(6),
                      GetByte(5) << 8 | GetByte(4), GetByte(3) << 8 | GetByte(2),
                      GetByte(1) << 8 | GetByte(0));
 }
 
 std::string CNetAddr::ToString() const {
     return ToStringIP();
 }
 
 bool operator==(const CNetAddr &a, const CNetAddr &b) {
     return (memcmp(a.ip, b.ip, 16) == 0);
 }
 
 bool operator<(const CNetAddr &a, const CNetAddr &b) {
     return (memcmp(a.ip, b.ip, 16) < 0);
 }
 
 bool CNetAddr::GetInAddr(struct in_addr *pipv4Addr) const {
     if (!IsIPv4()) {
         return false;
     }
     memcpy(pipv4Addr, ip + 12, 4);
     return true;
 }
 
 bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const {
     memcpy(pipv6Addr, ip, 16);
     return true;
 }
 
 // get canonical identifier of an address' group no two connections will be
 // attempted to addresses with the same group
 std::vector<uint8_t> CNetAddr::GetGroup() const {
     std::vector<uint8_t> vchRet;
     int nClass = NET_IPV6;
     int nStartByte = 0;
     int nBits = 16;
 
     // all local addresses belong to the same group
     if (IsLocal()) {
         nClass = 255;
         nBits = 0;
     }
 
     if (IsInternal()) {
         // all internal-usage addresses get their own group
         nClass = NET_INTERNAL;
         nStartByte = sizeof(g_internal_prefix);
         nBits = (sizeof(ip) - sizeof(g_internal_prefix)) * 8;
     } else if (!IsRoutable()) {
         // all other unroutable addresses belong to the same group
         nClass = NET_UNROUTABLE;
         nBits = 0;
     } else if (IsIPv4() || IsRFC6145() || IsRFC6052()) {
         // for IPv4 addresses, '1' + the 16 higher-order bits of the IP includes
         // mapped IPv4, SIIT translated IPv4, and the well-known prefix
         nClass = NET_IPV4;
         nStartByte = 12;
     } else if (IsRFC3964()) {
         // for 6to4 tunnelled addresses, use the encapsulated IPv4 address
         nClass = NET_IPV4;
         nStartByte = 2;
     } else if (IsRFC4380()) {
         // for Teredo-tunnelled IPv6 addresses, use the encapsulated IPv4
         // address
         vchRet.push_back(NET_IPV4);
         vchRet.push_back(GetByte(3) ^ 0xFF);
         vchRet.push_back(GetByte(2) ^ 0xFF);
         return vchRet;
     } else if (IsTor()) {
         nClass = NET_ONION;
         nStartByte = 6;
         nBits = 4;
     } else if (GetByte(15) == 0x20 && GetByte(14) == 0x01 &&
                GetByte(13) == 0x04 && GetByte(12) == 0x70) {
         // for he.net, use /36 groups
         nBits = 36;
     } else {
         // for the rest of the IPv6 network, use /32 groups
         nBits = 32;
     }
 
     vchRet.push_back(nClass);
     while (nBits >= 8) {
         vchRet.push_back(GetByte(15 - nStartByte));
         nStartByte++;
         nBits -= 8;
     }
     if (nBits > 0) {
         vchRet.push_back(GetByte(15 - nStartByte) | ((1 << (8 - nBits)) - 1));
     }
 
     return vchRet;
 }
 
 uint64_t CNetAddr::GetHash() const {
     uint256 hash = Hash(&ip[0], &ip[16]);
     uint64_t nRet;
     memcpy(&nRet, &hash, sizeof(nRet));
     return nRet;
 }
 
 // private extensions to enum Network, only returned by GetExtNetwork, and only
 // used in GetReachabilityFrom
 static const int NET_UNKNOWN = NET_MAX + 0;
 static const int NET_TEREDO = NET_MAX + 1;
 static int GetExtNetwork(const CNetAddr *addr) {
     if (addr == nullptr) {
         return NET_UNKNOWN;
     }
     if (addr->IsRFC4380()) {
         return NET_TEREDO;
     }
     return addr->GetNetwork();
 }
 
 /** Calculates a metric for how reachable (*this) is from a given partner */
 int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const {
     enum Reachability {
         REACH_UNREACHABLE,
         REACH_DEFAULT,
         REACH_TEREDO,
         REACH_IPV6_WEAK,
         REACH_IPV4,
         REACH_IPV6_STRONG,
         REACH_PRIVATE
     };
 
     if (!IsRoutable() || IsInternal()) {
         return REACH_UNREACHABLE;
     }
 
     int ourNet = GetExtNetwork(this);
     int theirNet = GetExtNetwork(paddrPartner);
     bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
 
     switch (theirNet) {
         case NET_IPV4:
             switch (ourNet) {
                 default:
                     return REACH_DEFAULT;
                 case NET_IPV4:
                     return REACH_IPV4;
             }
         case NET_IPV6:
             switch (ourNet) {
                 default:
                     return REACH_DEFAULT;
                 case NET_TEREDO:
                     return REACH_TEREDO;
                 case NET_IPV4:
                     return REACH_IPV4;
                 // only prefer giving our IPv6 address if it's not tunnelled
                 case NET_IPV6:
                     return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
             }
         case NET_ONION:
             switch (ourNet) {
                 default:
                     return REACH_DEFAULT;
                 // Tor users can connect to IPv4 as well
                 case NET_IPV4:
                     return REACH_IPV4;
                 case NET_ONION:
                     return REACH_PRIVATE;
             }
         case NET_TEREDO:
             switch (ourNet) {
                 default:
                     return REACH_DEFAULT;
                 case NET_TEREDO:
                     return REACH_TEREDO;
                 case NET_IPV6:
                     return REACH_IPV6_WEAK;
                 case NET_IPV4:
                     return REACH_IPV4;
             }
         case NET_UNKNOWN:
         case NET_UNROUTABLE:
         default:
             switch (ourNet) {
                 default:
                     return REACH_DEFAULT;
                 case NET_TEREDO:
                     return REACH_TEREDO;
                 case NET_IPV6:
                     return REACH_IPV6_WEAK;
                 case NET_IPV4:
                     return REACH_IPV4;
                 // either from Tor, or don't care about our address
                 case NET_ONION:
                     return REACH_PRIVATE;
             }
     }
 }
 
 CService::CService() : port(0) {}
 
 CService::CService(const CNetAddr &cip, unsigned short portIn)
     : CNetAddr(cip), port(portIn) {}
 
 CService::CService(const struct in_addr &ipv4Addr, unsigned short portIn)
     : CNetAddr(ipv4Addr), port(portIn) {}
 
 CService::CService(const struct in6_addr &ipv6Addr, unsigned short portIn)
     : CNetAddr(ipv6Addr), port(portIn) {}
 
 CService::CService(const struct sockaddr_in &addr)
     : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port)) {
     assert(addr.sin_family == AF_INET);
 }
 
 CService::CService(const struct sockaddr_in6 &addr)
     : CNetAddr(addr.sin6_addr, addr.sin6_scope_id),
       port(ntohs(addr.sin6_port)) {
     assert(addr.sin6_family == AF_INET6);
 }
 
 bool CService::SetSockAddr(const struct sockaddr *paddr) {
     switch (paddr->sa_family) {
         case AF_INET:
             *this =
                 CService(*reinterpret_cast<const struct sockaddr_in *>(paddr));
             return true;
         case AF_INET6:
             *this =
                 CService(*reinterpret_cast<const struct sockaddr_in6 *>(paddr));
             return true;
         default:
             return false;
     }
 }
 
 unsigned short CService::GetPort() const {
     return port;
 }
 
 bool operator==(const CService &a, const CService &b) {
     return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
            a.port == b.port;
 }
 
 bool operator<(const CService &a, const CService &b) {
     return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) ||
            (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
             a.port < b.port);
 }
 
 bool CService::GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const {
     if (IsIPv4()) {
         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in)) {
             return false;
         }
         *addrlen = sizeof(struct sockaddr_in);
         struct sockaddr_in *paddrin =
             reinterpret_cast<struct sockaddr_in *>(paddr);
         memset(paddrin, 0, *addrlen);
         if (!GetInAddr(&paddrin->sin_addr)) {
             return false;
         }
         paddrin->sin_family = AF_INET;
         paddrin->sin_port = htons(port);
         return true;
     }
     if (IsIPv6()) {
         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6)) {
             return false;
         }
         *addrlen = sizeof(struct sockaddr_in6);
         struct sockaddr_in6 *paddrin6 =
             reinterpret_cast<struct sockaddr_in6 *>(paddr);
         memset(paddrin6, 0, *addrlen);
         if (!GetIn6Addr(&paddrin6->sin6_addr)) {
             return false;
         }
         paddrin6->sin6_scope_id = scopeId;
         paddrin6->sin6_family = AF_INET6;
         paddrin6->sin6_port = htons(port);
         return true;
     }
     return false;
 }
 
 std::vector<uint8_t> CService::GetKey() const {
     std::vector<uint8_t> vKey;
     vKey.resize(18);
-    memcpy(&vKey[0], ip, 16);
+    memcpy(vKey.data(), ip, 16);
     vKey[16] = port / 0x100;
     vKey[17] = port & 0x0FF;
     return vKey;
 }
 
 std::string CService::ToStringPort() const {
     return strprintf("%u", port);
 }
 
 std::string CService::ToStringIPPort() const {
     if (IsIPv4() || IsTor() || IsInternal()) {
         return ToStringIP() + ":" + ToStringPort();
     } else {
         return "[" + ToStringIP() + "]:" + ToStringPort();
     }
 }
 
 std::string CService::ToString() const {
     return ToStringIPPort();
 }
 
 CSubNet::CSubNet() : valid(false) {
     memset(netmask, 0, sizeof(netmask));
 }
 
 CSubNet::CSubNet(const CNetAddr &addr, int32_t mask) {
     valid = true;
     network = addr;
     // Default to /32 (IPv4) or /128 (IPv6), i.e. match single address
     memset(netmask, 255, sizeof(netmask));
 
     // IPv4 addresses start at offset 12, and first 12 bytes must match, so just
     // offset n
     const int astartofs = network.IsIPv4() ? 12 : 0;
 
     // Only valid if in range of bits of address
     int32_t n = mask;
     if (n >= 0 && n <= (128 - astartofs * 8)) {
         n += astartofs * 8;
         // Clear bits [n..127]
         for (; n < 128; ++n) {
             netmask[n >> 3] &= ~(1 << (7 - (n & 7)));
         }
     } else {
         valid = false;
     }
 
     // Normalize network according to netmask
     for (int x = 0; x < 16; ++x) {
         network.ip[x] &= netmask[x];
     }
 }
 
 CSubNet::CSubNet(const CNetAddr &addr, const CNetAddr &mask) {
     valid = true;
     network = addr;
     // Default to /32 (IPv4) or /128 (IPv6), i.e. match single address
     memset(netmask, 255, sizeof(netmask));
 
     // IPv4 addresses start at offset 12, and first 12 bytes must match, so just
     // offset n
     const int astartofs = network.IsIPv4() ? 12 : 0;
 
     for (int x = astartofs; x < 16; ++x) {
         netmask[x] = mask.ip[x];
     }
 
     // Normalize network according to netmask
     for (int x = 0; x < 16; ++x) {
         network.ip[x] &= netmask[x];
     }
 }
 
 CSubNet::CSubNet(const CNetAddr &addr) : valid(addr.IsValid()) {
     memset(netmask, 255, sizeof(netmask));
     network = addr;
 }
 
 bool CSubNet::Match(const CNetAddr &addr) const {
     if (!valid || !addr.IsValid()) {
         return false;
     }
     for (int x = 0; x < 16; ++x) {
         if ((addr.ip[x] & netmask[x]) != network.ip[x]) {
             return false;
         }
     }
     return true;
 }
 
 static inline int NetmaskBits(uint8_t x) {
     switch (x) {
         case 0x00:
             return 0;
         case 0x80:
             return 1;
         case 0xc0:
             return 2;
         case 0xe0:
             return 3;
         case 0xf0:
             return 4;
         case 0xf8:
             return 5;
         case 0xfc:
             return 6;
         case 0xfe:
             return 7;
         case 0xff:
             return 8;
         default:
             return -1;
     }
 }
 
 std::string CSubNet::ToString() const {
     /* Parse binary 1{n}0{N-n} to see if mask can be represented as /n */
     int cidr = 0;
     bool valid_cidr = true;
     int n = network.IsIPv4() ? 12 : 0;
     for (; n < 16 && netmask[n] == 0xff; ++n) {
         cidr += 8;
     }
     if (n < 16) {
         int bits = NetmaskBits(netmask[n]);
         if (bits < 0) {
             valid_cidr = false;
         } else {
             cidr += bits;
         }
         ++n;
     }
     for (; n < 16 && valid_cidr; ++n) {
         if (netmask[n] != 0x00) {
             valid_cidr = false;
         }
     }
 
     /* Format output */
     std::string strNetmask;
     if (valid_cidr) {
         strNetmask = strprintf("%u", cidr);
     } else {
         if (network.IsIPv4()) {
             strNetmask = strprintf("%u.%u.%u.%u", netmask[12], netmask[13],
                                    netmask[14], netmask[15]);
         } else {
             strNetmask = strprintf(
                 "%x:%x:%x:%x:%x:%x:%x:%x", netmask[0] << 8 | netmask[1],
                 netmask[2] << 8 | netmask[3], netmask[4] << 8 | netmask[5],
                 netmask[6] << 8 | netmask[7], netmask[8] << 8 | netmask[9],
                 netmask[10] << 8 | netmask[11], netmask[12] << 8 | netmask[13],
                 netmask[14] << 8 | netmask[15]);
         }
     }
 
     return network.ToString() + "/" + strNetmask;
 }
 
 bool CSubNet::IsValid() const {
     return valid;
 }
 
 bool operator==(const CSubNet &a, const CSubNet &b) {
     return a.valid == b.valid && a.network == b.network &&
            !memcmp(a.netmask, b.netmask, 16);
 }
 
 bool operator<(const CSubNet &a, const CSubNet &b) {
     return (a.network < b.network ||
             (a.network == b.network && memcmp(a.netmask, b.netmask, 16) < 0));
 }
diff --git a/src/pubkey.cpp b/src/pubkey.cpp
index 6bb3e15ce..145035772 100644
--- a/src/pubkey.cpp
+++ b/src/pubkey.cpp
@@ -1,354 +1,351 @@
 // 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.
 
 #include <pubkey.h>
 
 #include <secp256k1.h>
 #include <secp256k1_recovery.h>
 #include <secp256k1_schnorr.h>
 
 namespace {
 /* Global secp256k1_context object used for verification. */
 secp256k1_context *secp256k1_context_verify = nullptr;
 } // namespace
 
 /**
  * This function is taken from the libsecp256k1 distribution and implements DER
  * parsing for ECDSA signatures, while supporting an arbitrary subset of format
  * violations.
  *
  * Supported violations include negative integers, excessive padding, garbage at
  * the end, and overly long length descriptors. This is safe to use in Bitcoin
  * because since the activation of BIP66, signatures are verified to be strict
  * DER before being passed to this module, and we know it supports all
  * violations present in the blockchain before that point.
  */
 static int ecdsa_signature_parse_der_lax(const secp256k1_context *ctx,
                                          secp256k1_ecdsa_signature *sig,
                                          const uint8_t *input,
                                          size_t inputlen) {
     size_t rpos, rlen, spos, slen;
     size_t pos = 0;
     size_t lenbyte;
     uint8_t tmpsig[64] = {0};
     int overflow = 0;
 
     /* Hack to initialize sig with a correctly-parsed but invalid signature. */
     secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
 
     /* Sequence tag byte */
     if (pos == inputlen || input[pos] != 0x30) {
         return 0;
     }
     pos++;
 
     /* Sequence length bytes */
     if (pos == inputlen) {
         return 0;
     }
     lenbyte = input[pos++];
     if (lenbyte & 0x80) {
         lenbyte -= 0x80;
         if (pos + lenbyte > inputlen) {
             return 0;
         }
         pos += lenbyte;
     }
 
     /* Integer tag byte for R */
     if (pos == inputlen || input[pos] != 0x02) {
         return 0;
     }
     pos++;
 
     /* Integer length for R */
     if (pos == inputlen) {
         return 0;
     }
     lenbyte = input[pos++];
     if (lenbyte & 0x80) {
         lenbyte -= 0x80;
         if (pos + lenbyte > inputlen) {
             return 0;
         }
         while (lenbyte > 0 && input[pos] == 0) {
             pos++;
             lenbyte--;
         }
         if (lenbyte >= sizeof(size_t)) {
             return 0;
         }
         rlen = 0;
         while (lenbyte > 0) {
             rlen = (rlen << 8) + input[pos];
             pos++;
             lenbyte--;
         }
     } else {
         rlen = lenbyte;
     }
     if (rlen > inputlen - pos) {
         return 0;
     }
     rpos = pos;
     pos += rlen;
 
     /* Integer tag byte for S */
     if (pos == inputlen || input[pos] != 0x02) {
         return 0;
     }
     pos++;
 
     /* Integer length for S */
     if (pos == inputlen) {
         return 0;
     }
     lenbyte = input[pos++];
     if (lenbyte & 0x80) {
         lenbyte -= 0x80;
         if (pos + lenbyte > inputlen) {
             return 0;
         }
         while (lenbyte > 0 && input[pos] == 0) {
             pos++;
             lenbyte--;
         }
         if (lenbyte >= sizeof(size_t)) {
             return 0;
         }
         slen = 0;
         while (lenbyte > 0) {
             slen = (slen << 8) + input[pos];
             pos++;
             lenbyte--;
         }
     } else {
         slen = lenbyte;
     }
     if (slen > inputlen - pos) {
         return 0;
     }
     spos = pos;
 
     /* Ignore leading zeroes in R */
     while (rlen > 0 && input[rpos] == 0) {
         rlen--;
         rpos++;
     }
     /* Copy R value */
     if (rlen > 32) {
         overflow = 1;
     } else {
         memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
     }
 
     /* Ignore leading zeroes in S */
     while (slen > 0 && input[spos] == 0) {
         slen--;
         spos++;
     }
     /* Copy S value */
     if (slen > 32) {
         overflow = 1;
     } else {
         memcpy(tmpsig + 64 - slen, input + spos, slen);
     }
 
     if (!overflow) {
         overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
     }
     if (overflow) {
         /* Overwrite the result again with a correctly-parsed but invalid
            signature if parsing failed. */
         memset(tmpsig, 0, 64);
         secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
     }
     return 1;
 }
 
 bool CPubKey::VerifyECDSA(const uint256 &hash,
                           const std::vector<uint8_t> &vchSig) const {
     if (!IsValid()) {
         return false;
     }
 
     secp256k1_pubkey pubkey;
     secp256k1_ecdsa_signature sig;
     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey,
                                    &(*this)[0], size())) {
         return false;
     }
-    if (vchSig.size() == 0) {
-        return false;
-    }
     if (!ecdsa_signature_parse_der_lax(secp256k1_context_verify, &sig,
-                                       &vchSig[0], vchSig.size())) {
+                                       vchSig.data(), vchSig.size())) {
         return false;
     }
     /**
      * libsecp256k1's ECDSA verification requires lower-S signatures, which have
      * not historically been enforced in Bitcoin, so normalize them first.
      */
     secp256k1_ecdsa_signature_normalize(secp256k1_context_verify, &sig, &sig);
     return secp256k1_ecdsa_verify(secp256k1_context_verify, &sig, hash.begin(),
                                   &pubkey);
 }
 
 bool CPubKey::VerifySchnorr(const uint256 &hash,
                             const std::vector<uint8_t> &vchSig) const {
     if (!IsValid()) {
         return false;
     }
 
     if (vchSig.size() != 64) {
         return false;
     }
 
     secp256k1_pubkey pubkey;
     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey,
                                    &(*this)[0], size())) {
         return false;
     }
 
     return secp256k1_schnorr_verify(secp256k1_context_verify, &vchSig[0],
                                     hash.begin(), &pubkey);
 }
 
 bool CPubKey::RecoverCompact(const uint256 &hash,
                              const std::vector<uint8_t> &vchSig) {
     if (vchSig.size() != 65) {
         return false;
     }
 
     int recid = (vchSig[0] - 27) & 3;
     bool fComp = ((vchSig[0] - 27) & 4) != 0;
     secp256k1_pubkey pubkey;
     secp256k1_ecdsa_recoverable_signature sig;
     if (!secp256k1_ecdsa_recoverable_signature_parse_compact(
             secp256k1_context_verify, &sig, &vchSig[1], recid)) {
         return false;
     }
     if (!secp256k1_ecdsa_recover(secp256k1_context_verify, &pubkey, &sig,
                                  hash.begin())) {
         return false;
     }
     uint8_t pub[65];
     size_t publen = 65;
     secp256k1_ec_pubkey_serialize(
         secp256k1_context_verify, pub, &publen, &pubkey,
         fComp ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
     Set(pub, pub + publen);
     return true;
 }
 
 bool CPubKey::IsFullyValid() const {
     if (!IsValid()) {
         return false;
     }
     secp256k1_pubkey pubkey;
     return secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey,
                                      &(*this)[0], size());
 }
 
 bool CPubKey::Decompress() {
     if (!IsValid()) {
         return false;
     }
     secp256k1_pubkey pubkey;
     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey,
                                    &(*this)[0], size())) {
         return false;
     }
     uint8_t pub[65];
     size_t publen = 65;
     secp256k1_ec_pubkey_serialize(secp256k1_context_verify, pub, &publen,
                                   &pubkey, SECP256K1_EC_UNCOMPRESSED);
     Set(pub, pub + publen);
     return true;
 }
 
 bool CPubKey::Derive(CPubKey &pubkeyChild, ChainCode &ccChild,
                      unsigned int nChild, const ChainCode &cc) const {
     assert(IsValid());
     assert((nChild >> 31) == 0);
     assert(begin() + 33 == end());
     uint8_t out[64];
     BIP32Hash(cc, nChild, *begin(), begin() + 1, out);
     memcpy(ccChild.begin(), out + 32, 32);
     secp256k1_pubkey pubkey;
     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey,
                                    &(*this)[0], size())) {
         return false;
     }
     if (!secp256k1_ec_pubkey_tweak_add(secp256k1_context_verify, &pubkey,
                                        out)) {
         return false;
     }
     uint8_t pub[33];
     size_t publen = 33;
     secp256k1_ec_pubkey_serialize(secp256k1_context_verify, pub, &publen,
                                   &pubkey, SECP256K1_EC_COMPRESSED);
     pubkeyChild.Set(pub, pub + publen);
     return true;
 }
 
 void CExtPubKey::Encode(uint8_t code[BIP32_EXTKEY_SIZE]) const {
     code[0] = nDepth;
     memcpy(code + 1, vchFingerprint, 4);
     code[5] = (nChild >> 24) & 0xFF;
     code[6] = (nChild >> 16) & 0xFF;
     code[7] = (nChild >> 8) & 0xFF;
     code[8] = (nChild >> 0) & 0xFF;
     memcpy(code + 9, chaincode.begin(), 32);
     assert(pubkey.size() == 33);
     memcpy(code + 41, pubkey.begin(), 33);
 }
 
 void CExtPubKey::Decode(const uint8_t code[BIP32_EXTKEY_SIZE]) {
     nDepth = code[0];
     memcpy(vchFingerprint, code + 1, 4);
     nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
     memcpy(chaincode.begin(), code + 9, 32);
     pubkey.Set(code + 41, code + BIP32_EXTKEY_SIZE);
 }
 
 bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {
     out.nDepth = nDepth + 1;
     CKeyID id = pubkey.GetID();
     memcpy(&out.vchFingerprint[0], &id, 4);
     out.nChild = _nChild;
     return pubkey.Derive(out.pubkey, out.chaincode, _nChild, chaincode);
 }
 
 bool CPubKey::CheckLowS(
     const boost::sliced_range<const std::vector<uint8_t>> &vchSig) {
     secp256k1_ecdsa_signature sig;
     if (!ecdsa_signature_parse_der_lax(secp256k1_context_verify, &sig,
-                                       &vchSig[0], vchSig.size())) {
+                                       &vchSig.front(), vchSig.size())) {
         return false;
     }
     return (!secp256k1_ecdsa_signature_normalize(secp256k1_context_verify,
                                                  nullptr, &sig));
 }
 
 /* static */ int ECCVerifyHandle::refcount = 0;
 
 ECCVerifyHandle::ECCVerifyHandle() {
     if (refcount == 0) {
         assert(secp256k1_context_verify == nullptr);
         secp256k1_context_verify =
             secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
         assert(secp256k1_context_verify != nullptr);
     }
     refcount++;
 }
 
 ECCVerifyHandle::~ECCVerifyHandle() {
     refcount--;
     if (refcount == 0) {
         assert(secp256k1_context_verify != nullptr);
         secp256k1_context_destroy(secp256k1_context_verify);
         secp256k1_context_verify = nullptr;
     }
 }
diff --git a/src/serialize.h b/src/serialize.h
index 91ff6846a..b7149a49e 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -1,922 +1,922 @@
 // 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_SERIALIZE_H
 #define BITCOIN_SERIALIZE_H
 
 #include <compat/endian.h>
 #include <prevector.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 static const uint64_t MAX_SIZE = 0x02000000;
 
 /**
  * Dummy data type to identify deserializing constructors.
  *
  * By convention, a constructor of a type T with signature
  *
  *   template <typename Stream> T::T(deserialize_type, Stream& s)
  *
  * is a deserializing constructor, which builds the type by deserializing it
  * from s. If T contains const fields, this is likely the only way to do so.
  */
 struct deserialize_type {};
 constexpr deserialize_type deserialize{};
 
 /**
  * Used to bypass the rule against non-const reference to temporary where it
  * makes sense with wrappers such as CFlatData or CTxDB
  */
 template <typename T> inline T &REF(const T &val) {
     return const_cast<T &>(val);
 }
 
 /**
  * Used to acquire a non-const pointer "this" to generate bodies of const
  * serialization operations from a template
  */
 template <typename T> inline T *NCONST_PTR(const T *val) {
     return const_cast<T *>(val);
 }
 
 /*
  * Lowest-level serialization and conversion.
  * @note Sizes of these types are verified in the tests
  */
 template <typename Stream> inline void ser_writedata8(Stream &s, uint8_t obj) {
     s.write((char *)&obj, 1);
 }
 template <typename Stream>
 inline void ser_writedata16(Stream &s, uint16_t obj) {
     obj = htole16(obj);
     s.write((char *)&obj, 2);
 }
 template <typename Stream>
 inline void ser_writedata32(Stream &s, uint32_t obj) {
     obj = htole32(obj);
     s.write((char *)&obj, 4);
 }
 template <typename Stream>
 inline void ser_writedata32be(Stream &s, uint32_t obj) {
     obj = htobe32(obj);
     s.write((char *)&obj, 4);
 }
 template <typename Stream>
 inline void ser_writedata64(Stream &s, uint64_t obj) {
     obj = htole64(obj);
     s.write((char *)&obj, 8);
 }
 template <typename Stream> inline uint8_t ser_readdata8(Stream &s) {
     uint8_t obj;
     s.read((char *)&obj, 1);
     return obj;
 }
 template <typename Stream> inline uint16_t ser_readdata16(Stream &s) {
     uint16_t obj;
     s.read((char *)&obj, 2);
     return le16toh(obj);
 }
 template <typename Stream> inline uint32_t ser_readdata32(Stream &s) {
     uint32_t obj;
     s.read((char *)&obj, 4);
     return le32toh(obj);
 }
 template <typename Stream> inline uint32_t ser_readdata32be(Stream &s) {
     uint32_t obj;
     s.read((char *)&obj, 4);
     return be32toh(obj);
 }
 template <typename Stream> inline uint64_t ser_readdata64(Stream &s) {
     uint64_t obj;
     s.read((char *)&obj, 8);
     return le64toh(obj);
 }
 inline uint64_t ser_double_to_uint64(double x) {
     union {
         double x;
         uint64_t y;
     } tmp;
     tmp.x = x;
     return tmp.y;
 }
 inline uint32_t ser_float_to_uint32(float x) {
     union {
         float x;
         uint32_t y;
     } tmp;
     tmp.x = x;
     return tmp.y;
 }
 inline double ser_uint64_to_double(uint64_t y) {
     union {
         double x;
         uint64_t y;
     } tmp;
     tmp.y = y;
     return tmp.x;
 }
 inline float ser_uint32_to_float(uint32_t y) {
     union {
         float x;
         uint32_t y;
     } tmp;
     tmp.y = y;
     return tmp.x;
 }
 
 /////////////////////////////////////////////////////////////////
 //
 // Templates for serializing to anything that looks like a stream,
 // i.e. anything that supports .read(char*, size_t) and .write(char*, size_t)
 //
 class CSizeComputer;
 
 enum {
     // primary actions
     SER_NETWORK = (1 << 0),
     SER_DISK = (1 << 1),
     SER_GETHASH = (1 << 2),
 };
 
 //! Convert the reference base type to X, without changing constness or
 //! reference type.
 template <typename X> X &ReadWriteAsHelper(X &x) {
     return x;
 }
 template <typename X> const X &ReadWriteAsHelper(const X &x) {
     return x;
 }
 
 #define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 #define READWRITEAS(type, obj)                                                 \
     (::SerReadWriteMany(s, ser_action, ReadWriteAsHelper<type>(obj)))
 
 /**
  * Implement three methods for serializable objects. These are actually wrappers
  * over "SerializationOp" template, which implements the body of each class'
  * serialization code. Adding "ADD_SERIALIZE_METHODS" in the body of the class
  * causes these wrappers to be added as members.
  */
 #define ADD_SERIALIZE_METHODS                                                  \
     template <typename Stream> void Serialize(Stream &s) const {               \
         NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize());           \
     }                                                                          \
     template <typename Stream> void Unserialize(Stream &s) {                   \
         SerializationOp(s, CSerActionUnserialize());                           \
     }
 
 template <typename Stream> inline void Serialize(Stream &s, char a) {
     ser_writedata8(s, a);
 } // TODO Get rid of bare char
 template <typename Stream> inline void Serialize(Stream &s, int8_t a) {
     ser_writedata8(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint8_t a) {
     ser_writedata8(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, int16_t a) {
     ser_writedata16(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint16_t a) {
     ser_writedata16(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, int32_t a) {
     ser_writedata32(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint32_t a) {
     ser_writedata32(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, int64_t a) {
     ser_writedata64(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, uint64_t a) {
     ser_writedata64(s, a);
 }
 template <typename Stream> inline void Serialize(Stream &s, float a) {
     ser_writedata32(s, ser_float_to_uint32(a));
 }
 template <typename Stream> inline void Serialize(Stream &s, double a) {
     ser_writedata64(s, ser_double_to_uint64(a));
 }
 // TODO Get rid of bare char
 template <typename Stream> inline void Unserialize(Stream &s, char &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int8_t &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint8_t &a) {
     a = ser_readdata8(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int16_t &a) {
     a = ser_readdata16(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint16_t &a) {
     a = ser_readdata16(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int32_t &a) {
     a = ser_readdata32(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint32_t &a) {
     a = ser_readdata32(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, int64_t &a) {
     a = ser_readdata64(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, uint64_t &a) {
     a = ser_readdata64(s);
 }
 template <typename Stream> inline void Unserialize(Stream &s, float &a) {
     a = ser_uint32_to_float(ser_readdata32(s));
 }
 template <typename Stream> inline void Unserialize(Stream &s, double &a) {
     a = ser_uint64_to_double(ser_readdata64(s));
 }
 
 template <typename Stream> inline void Serialize(Stream &s, bool a) {
     char f = a;
     ser_writedata8(s, f);
 }
 template <typename Stream> inline void Unserialize(Stream &s, bool &a) {
     char f = ser_readdata8(s);
     a = f;
 }
 
 /**
  * Compact Size
  * size <  253        -- 1 byte
  * size <= USHRT_MAX  -- 3 bytes  (253 + 2 bytes)
  * size <= UINT_MAX   -- 5 bytes  (254 + 4 bytes)
  * size >  UINT_MAX   -- 9 bytes  (255 + 8 bytes)
  */
 inline uint32_t GetSizeOfCompactSize(uint64_t nSize) {
     if (nSize < 253) {
         return sizeof(uint8_t);
     }
     if (nSize <= std::numeric_limits<uint16_t>::max()) {
         return sizeof(uint8_t) + sizeof(uint16_t);
     }
     if (nSize <= std::numeric_limits<uint32_t>::max()) {
         return sizeof(uint8_t) + sizeof(uint32_t);
     }
 
     return sizeof(uint8_t) + sizeof(uint64_t);
 }
 
 inline void WriteCompactSize(CSizeComputer &os, uint64_t nSize);
 
 template <typename Stream> void WriteCompactSize(Stream &os, uint64_t nSize) {
     if (nSize < 253) {
         ser_writedata8(os, nSize);
     } else if (nSize <= std::numeric_limits<uint16_t>::max()) {
         ser_writedata8(os, 253);
         ser_writedata16(os, nSize);
     } else if (nSize <= std::numeric_limits<uint32_t>::max()) {
         ser_writedata8(os, 254);
         ser_writedata32(os, nSize);
     } else {
         ser_writedata8(os, 255);
         ser_writedata64(os, nSize);
     }
     return;
 }
 
 template <typename Stream> uint64_t ReadCompactSize(Stream &is) {
     uint8_t chSize = ser_readdata8(is);
     uint64_t nSizeRet = 0;
     if (chSize < 253) {
         nSizeRet = chSize;
     } else if (chSize == 253) {
         nSizeRet = ser_readdata16(is);
         if (nSizeRet < 253) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     } else if (chSize == 254) {
         nSizeRet = ser_readdata32(is);
         if (nSizeRet < 0x10000u) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     } else {
         nSizeRet = ser_readdata64(is);
         if (nSizeRet < 0x100000000ULL) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
         }
     }
     if (nSizeRet > MAX_SIZE) {
         throw std::ios_base::failure("ReadCompactSize(): size too large");
     }
     return nSizeRet;
 }
 
 /**
  * Variable-length integers: bytes are a MSB base-128 encoding of the number.
  * The high bit in each byte signifies whether another digit follows. To make
  * sure the encoding is one-to-one, one is subtracted from all but the last
  * digit. Thus, the byte sequence a[] with length len, where all but the last
  * byte has bit 128 set, encodes the number:
  *
  *  (a[len-1] & 0x7F) + sum(i=1..len-1, 128^i*((a[len-i-1] & 0x7F)+1))
  *
  * Properties:
  * * Very small (0-127: 1 byte, 128-16511: 2 bytes, 16512-2113663: 3 bytes)
  * * Every integer has exactly one encoding
  * * Encoding does not depend on size of original integer type
  * * No redundancy: every (infinite) byte sequence corresponds to a list
  *   of encoded integers.
  *
  * 0:         [0x00]  256:        [0x81 0x00]
  * 1:         [0x01]  16383:      [0xFE 0x7F]
  * 127:       [0x7F]  16384:      [0xFF 0x00]
  * 128:  [0x80 0x00]  16511:      [0xFF 0x7F]
  * 255:  [0x80 0x7F]  65535: [0x82 0xFE 0x7F]
  * 2^32:           [0x8E 0xFE 0xFE 0xFF 0x00]
  */
 template <typename I> inline unsigned int GetSizeOfVarInt(I n) {
     int nRet = 0;
     while (true) {
         nRet++;
         if (n <= 0x7F) {
             return nRet;
         }
         n = (n >> 7) - 1;
     }
 }
 
 template <typename I> inline void WriteVarInt(CSizeComputer &os, I n);
 
 template <typename Stream, typename I> void WriteVarInt(Stream &os, I n) {
     uint8_t tmp[(sizeof(n) * 8 + 6) / 7];
     int len = 0;
     while (true) {
         tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
         if (n <= 0x7F) {
             break;
         }
         n = (n >> 7) - 1;
         len++;
     }
     do {
         ser_writedata8(os, tmp[len]);
     } while (len--);
 }
 
 template <typename Stream, typename I> I ReadVarInt(Stream &is) {
     I n = 0;
     while (true) {
         uint8_t chData = ser_readdata8(is);
         if (n > (std::numeric_limits<I>::max() >> 7)) {
             throw std::ios_base::failure("ReadVarInt(): size too large");
         }
         n = (n << 7) | (chData & 0x7F);
         if ((chData & 0x80) == 0) {
             return n;
         }
         if (n == std::numeric_limits<I>::max()) {
             throw std::ios_base::failure("ReadVarInt(): size too large");
         }
         n++;
     }
 }
 
 #define FLATDATA(obj) CFlatData((char *)&(obj), (char *)&(obj) + sizeof(obj))
 #define VARINT(obj) WrapVarInt(REF(obj))
 #define COMPACTSIZE(obj) CCompactSize(REF(obj))
 #define LIMITED_STRING(obj, n) LimitedString<n>(REF(obj))
 
 /**
  * Wrapper for serializing arrays and POD.
  */
 class CFlatData {
 protected:
     char *pbegin;
     char *pend;
 
 public:
     CFlatData(void *pbeginIn, void *pendIn)
         : pbegin((char *)pbeginIn), pend((char *)pendIn) {}
     template <class T, class TAl> explicit CFlatData(std::vector<T, TAl> &v) {
         pbegin = (char *)v.data();
         pend = (char *)(v.data() + v.size());
     }
     template <unsigned int N, typename T, typename S, typename D>
     explicit CFlatData(prevector<N, T, S, D> &v) {
         pbegin = (char *)v.data();
         pend = (char *)(v.data() + v.size());
     }
     char *begin() { return pbegin; }
     const char *begin() const { return pbegin; }
     char *end() { return pend; }
     const char *end() const { return pend; }
 
     template <typename Stream> void Serialize(Stream &s) const {
         s.write(pbegin, pend - pbegin);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         s.read(pbegin, pend - pbegin);
     }
 };
 
 template <typename I> class CVarInt {
 protected:
     I &n;
 
 public:
     explicit CVarInt(I &nIn) : n(nIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteVarInt<Stream, I>(s, n);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         n = ReadVarInt<Stream, I>(s);
     }
 };
 
 class CCompactSize {
 protected:
     uint64_t &n;
 
 public:
     explicit CCompactSize(uint64_t &nIn) : n(nIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteCompactSize<Stream>(s, n);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         n = ReadCompactSize<Stream>(s);
     }
 };
 
 template <size_t Limit> class LimitedString {
 protected:
     std::string &string;
 
 public:
     explicit LimitedString(std::string &_string) : string(_string) {}
 
     template <typename Stream> void Unserialize(Stream &s) {
         size_t size = ReadCompactSize(s);
         if (size > Limit) {
             throw std::ios_base::failure("String length limit exceeded");
         }
         string.resize(size);
         if (size != 0) {
-            s.read((char *)&string[0], size);
+            s.read((char *)string.data(), size);
         }
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteCompactSize(s, string.size());
         if (!string.empty()) {
-            s.write((char *)&string[0], string.size());
+            s.write((char *)string.data(), string.size());
         }
     }
 };
 
 template <typename I> CVarInt<I> WrapVarInt(I &n) {
     return CVarInt<I>(n);
 }
 
 /**
  * Forward declarations
  */
 
 /**
  *  string
  */
 template <typename Stream, typename C>
 void Serialize(Stream &os, const std::basic_string<C> &str);
 template <typename Stream, typename C>
 void Unserialize(Stream &is, std::basic_string<C> &str);
 
 /**
  * prevector
  * prevectors of uint8_t are a special case and are intended to be serialized as
  * a single opaque blob.
  */
 template <typename Stream, unsigned int N, typename T>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const uint8_t &);
 template <typename Stream, unsigned int N, typename T, typename V>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const V &);
 template <typename Stream, unsigned int N, typename T>
 inline void Serialize(Stream &os, const prevector<N, T> &v);
 template <typename Stream, unsigned int N, typename T>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const uint8_t &);
 template <typename Stream, unsigned int N, typename T, typename V>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const V &);
 template <typename Stream, unsigned int N, typename T>
 inline void Unserialize(Stream &is, prevector<N, T> &v);
 
 /**
  * vector
  * vectors of uint8_t are a special case and are intended to be serialized as a
  * single opaque blob.
  */
 template <typename Stream, typename T, typename A>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const uint8_t &);
 template <typename Stream, typename T, typename A, typename V>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const V &);
 template <typename Stream, typename T, typename A>
 inline void Serialize(Stream &os, const std::vector<T, A> &v);
 template <typename Stream, typename T, typename A>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const uint8_t &);
 template <typename Stream, typename T, typename A, typename V>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const V &);
 template <typename Stream, typename T, typename A>
 inline void Unserialize(Stream &is, std::vector<T, A> &v);
 
 /**
  * pair
  */
 template <typename Stream, typename K, typename T>
 void Serialize(Stream &os, const std::pair<K, T> &item);
 template <typename Stream, typename K, typename T>
 void Unserialize(Stream &is, std::pair<K, T> &item);
 
 /**
  * map
  */
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Serialize(Stream &os, const std::map<K, T, Pred, A> &m);
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Unserialize(Stream &is, std::map<K, T, Pred, A> &m);
 
 /**
  * set
  */
 template <typename Stream, typename K, typename Pred, typename A>
 void Serialize(Stream &os, const std::set<K, Pred, A> &m);
 template <typename Stream, typename K, typename Pred, typename A>
 void Unserialize(Stream &is, std::set<K, Pred, A> &m);
 
 /**
  * shared_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::shared_ptr<const T> &p);
 template <typename Stream, typename T>
 void Unserialize(Stream &os, std::shared_ptr<const T> &p);
 
 /**
  * unique_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::unique_ptr<const T> &p);
 template <typename Stream, typename T>
 void Unserialize(Stream &os, std::unique_ptr<const T> &p);
 
 /**
  * If none of the specialized versions above matched, default to calling member
  * function.
  */
 template <typename Stream, typename T>
 inline void Serialize(Stream &os, const T &a) {
     a.Serialize(os);
 }
 
 template <typename Stream, typename T>
 inline void Unserialize(Stream &is, T &&a) {
     a.Unserialize(is);
 }
 
 /**
  * string
  */
 template <typename Stream, typename C>
 void Serialize(Stream &os, const std::basic_string<C> &str) {
     WriteCompactSize(os, str.size());
     if (!str.empty()) {
-        os.write((char *)&str[0], str.size() * sizeof(str[0]));
+        os.write((char *)str.data(), str.size() * sizeof(C));
     }
 }
 
 template <typename Stream, typename C>
 void Unserialize(Stream &is, std::basic_string<C> &str) {
     size_t nSize = ReadCompactSize(is);
     str.resize(nSize);
     if (nSize != 0) {
-        is.read((char *)&str[0], nSize * sizeof(str[0]));
+        is.read((char *)str.data(), nSize * sizeof(C));
     }
 }
 
 /**
  * prevector
  */
 template <typename Stream, unsigned int N, typename T>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
     if (!v.empty()) {
-        os.write((char *)&v[0], v.size() * sizeof(T));
+        os.write((char *)v.data(), v.size() * sizeof(T));
     }
 }
 
 template <typename Stream, unsigned int N, typename T, typename V>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const V &) {
     WriteCompactSize(os, v.size());
     for (const T &i : v) {
         ::Serialize(os, i);
     }
 }
 
 template <typename Stream, unsigned int N, typename T>
 inline void Serialize(Stream &os, const prevector<N, T> &v) {
     Serialize_impl(os, v, T());
 }
 
 template <typename Stream, unsigned int N, typename T>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     while (i < nSize) {
         size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
     }
 }
 
 template <typename Stream, unsigned int N, typename T, typename V>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const V &) {
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
         if (nMid > nSize) {
             nMid = nSize;
         }
         v.resize(nMid);
         for (; i < nMid; i++) {
             Unserialize(is, v[i]);
         }
     }
 }
 
 template <typename Stream, unsigned int N, typename T>
 inline void Unserialize(Stream &is, prevector<N, T> &v) {
     Unserialize_impl(is, v, T());
 }
 
 /**
  * vector
  */
 template <typename Stream, typename T, typename A>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
     if (!v.empty()) {
-        os.write((char *)&v[0], v.size() * sizeof(T));
+        os.write((char *)v.data(), v.size() * sizeof(T));
     }
 }
 
 template <typename Stream, typename T, typename A, typename V>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const V &) {
     WriteCompactSize(os, v.size());
     for (const T &i : v) {
         ::Serialize(os, i);
     }
 }
 
 template <typename Stream, typename T, typename A>
 inline void Serialize(Stream &os, const std::vector<T, A> &v) {
     Serialize_impl(os, v, T());
 }
 
 template <typename Stream, typename T, typename A>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     while (i < nSize) {
         size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
     }
 }
 
 template <typename Stream, typename T, typename A, typename V>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const V &) {
     v.clear();
     size_t nSize = ReadCompactSize(is);
     size_t i = 0;
     size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
         if (nMid > nSize) {
             nMid = nSize;
         }
         v.resize(nMid);
         for (; i < nMid; i++) {
             Unserialize(is, v[i]);
         }
     }
 }
 
 template <typename Stream, typename T, typename A>
 inline void Unserialize(Stream &is, std::vector<T, A> &v) {
     Unserialize_impl(is, v, T());
 }
 
 /**
  * pair
  */
 template <typename Stream, typename K, typename T>
 void Serialize(Stream &os, const std::pair<K, T> &item) {
     Serialize(os, item.first);
     Serialize(os, item.second);
 }
 
 template <typename Stream, typename K, typename T>
 void Unserialize(Stream &is, std::pair<K, T> &item) {
     Unserialize(is, item.first);
     Unserialize(is, item.second);
 }
 
 /**
  * map
  */
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Serialize(Stream &os, const std::map<K, T, Pred, A> &m) {
     WriteCompactSize(os, m.size());
     for (const auto &entry : m) {
         Serialize(os, entry);
     }
 }
 
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Unserialize(Stream &is, std::map<K, T, Pred, A> &m) {
     m.clear();
     size_t nSize = ReadCompactSize(is);
     typename std::map<K, T, Pred, A>::iterator mi = m.begin();
     for (size_t i = 0; i < nSize; i++) {
         std::pair<K, T> item;
         Unserialize(is, item);
         mi = m.insert(mi, item);
     }
 }
 
 /**
  * set
  */
 template <typename Stream, typename K, typename Pred, typename A>
 void Serialize(Stream &os, const std::set<K, Pred, A> &m) {
     WriteCompactSize(os, m.size());
     for (const K &i : m) {
         Serialize(os, i);
     }
 }
 
 template <typename Stream, typename K, typename Pred, typename A>
 void Unserialize(Stream &is, std::set<K, Pred, A> &m) {
     m.clear();
     size_t nSize = ReadCompactSize(is);
     typename std::set<K, Pred, A>::iterator it = m.begin();
     for (size_t i = 0; i < nSize; i++) {
         K key;
         Unserialize(is, key);
         it = m.insert(it, key);
     }
 }
 
 /**
  * unique_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::unique_ptr<const T> &p) {
     Serialize(os, *p);
 }
 
 template <typename Stream, typename T>
 void Unserialize(Stream &is, std::unique_ptr<const T> &p) {
     p.reset(new T(deserialize, is));
 }
 
 /**
  * shared_ptr
  */
 template <typename Stream, typename T>
 void Serialize(Stream &os, const std::shared_ptr<const T> &p) {
     Serialize(os, *p);
 }
 
 template <typename Stream, typename T>
 void Unserialize(Stream &is, std::shared_ptr<const T> &p) {
     p = std::make_shared<const T>(deserialize, is);
 }
 
 /**
  * Support for ADD_SERIALIZE_METHODS and READWRITE macro
  */
 struct CSerActionSerialize {
     constexpr bool ForRead() const { return false; }
 };
 struct CSerActionUnserialize {
     constexpr bool ForRead() const { return true; }
 };
 
 /**
  * ::GetSerializeSize implementations
  *
  * Computing the serialized size of objects is done through a special stream
  * object of type CSizeComputer, which only records the number of bytes written
  * to it.
  *
  * If your Serialize or SerializationOp method has non-trivial overhead for
  * serialization, it may be worthwhile to implement a specialized version for
  * CSizeComputer, which uses the s.seek() method to record bytes that would
  * be written instead.
  */
 class CSizeComputer {
 protected:
     size_t nSize;
 
     const int nType;
     const int nVersion;
 
 public:
     CSizeComputer(int nTypeIn, int nVersionIn)
         : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {}
 
     void write(const char *psz, size_t _nSize) { this->nSize += _nSize; }
 
     /** Pretend _nSize bytes are written, without specifying them. */
     void seek(size_t _nSize) { this->nSize += _nSize; }
 
     template <typename T> CSizeComputer &operator<<(const T &obj) {
         ::Serialize(*this, obj);
         return (*this);
     }
 
     size_t size() const { return nSize; }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 };
 
 template <typename Stream> void SerializeMany(Stream &s) {}
 
 template <typename Stream, typename Arg, typename... Args>
 void SerializeMany(Stream &s, const Arg &arg, const Args &... args) {
     ::Serialize(s, arg);
     ::SerializeMany(s, args...);
 }
 
 template <typename Stream> inline void UnserializeMany(Stream &s) {}
 
 template <typename Stream, typename Arg, typename... Args>
 inline void UnserializeMany(Stream &s, Arg &&arg, Args &&... args) {
     ::Unserialize(s, arg);
     ::UnserializeMany(s, args...);
 }
 
 template <typename Stream, typename... Args>
 inline void SerReadWriteMany(Stream &s, CSerActionSerialize ser_action,
                              const Args &... args) {
     ::SerializeMany(s, args...);
 }
 
 template <typename Stream, typename... Args>
 inline void SerReadWriteMany(Stream &s, CSerActionUnserialize ser_action,
                              Args &&... args) {
     ::UnserializeMany(s, args...);
 }
 
 template <typename I> inline void WriteVarInt(CSizeComputer &s, I n) {
     s.seek(GetSizeOfVarInt<I>(n));
 }
 
 inline void WriteCompactSize(CSizeComputer &s, uint64_t nSize) {
     s.seek(GetSizeOfCompactSize(nSize));
 }
 
 template <typename T>
 size_t GetSerializeSize(const T &t, int nType, int nVersion = 0) {
     return (CSizeComputer(nType, nVersion) << t).size();
 }
 
 template <typename S, typename T>
 size_t GetSerializeSize(const S &s, const T &t) {
     return (CSizeComputer(s.GetType(), s.GetVersion()) << t).size();
 }
 
 #endif // BITCOIN_SERIALIZE_H
diff --git a/src/streams.h b/src/streams.h
index 444e05ae9..8a8e1e856 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -1,820 +1,822 @@
 // 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_STREAMS_H
 #define BITCOIN_STREAMS_H
 
 #include <serialize.h>
 #include <support/allocators/zeroafterfree.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 template <typename Stream> class OverrideStream {
     Stream *stream;
 
     const int nType;
     const int nVersion;
 
 public:
     OverrideStream(Stream *stream_, int nType_, int nVersion_)
         : stream(stream_), nType(nType_), nVersion(nVersion_) {}
 
     template <typename T> OverrideStream<Stream> &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> OverrideStream<Stream> &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void write(const char *pch, size_t nSize) { stream->write(pch, nSize); }
 
     void read(char *pch, size_t nSize) { stream->read(pch, nSize); }
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 };
 
 template <typename S> OverrideStream<S> WithOrVersion(S *s, int nVersionFlag) {
     return OverrideStream<S>(s, s->GetType(), s->GetVersion() | nVersionFlag);
 }
 
 /**
  * Minimal stream for overwriting and/or appending to an existing byte vector.
  *
  * The referenced vector will grow as necessary.
  */
 class CVectorWriter {
 public:
     /**
      * @param[in]  nTypeIn Serialization Type
      * @param[in]  nVersionIn Serialization Version (including any flags)
      * @param[in]  vchDataIn  Referenced byte vector to overwrite/append
      * @param[in]  nPosIn Starting position. Vector index where writes should
      * start. The vector will initially grow as necessary to  max(nPosIn,
      * vec.size()). So to append, use vec.size().
      */
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn)
         : nType(nTypeIn), nVersion(nVersionIn), vchData(vchDataIn),
           nPos(nPosIn) {
         if (nPos > vchData.size()) vchData.resize(nPos);
     }
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to serialize starting at nPosIn.
      */
     template <typename... Args>
     CVectorWriter(int nTypeIn, int nVersionIn, std::vector<uint8_t> &vchDataIn,
                   size_t nPosIn, Args &&... args)
         : CVectorWriter(nTypeIn, nVersionIn, vchDataIn, nPosIn) {
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
     void write(const char *pch, size_t nSize) {
         assert(nPos <= vchData.size());
         size_t nOverwrite = std::min(nSize, vchData.size() - nPos);
         if (nOverwrite) {
             memcpy(vchData.data() + nPos,
                    reinterpret_cast<const uint8_t *>(pch), nOverwrite);
         }
         if (nOverwrite < nSize) {
             vchData.insert(vchData.end(),
                            reinterpret_cast<const uint8_t *>(pch) + nOverwrite,
                            reinterpret_cast<const uint8_t *>(pch) + nSize);
         }
         nPos += nSize;
     }
     template <typename T> CVectorWriter &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
     void seek(size_t nSize) {
         nPos += nSize;
         if (nPos > vchData.size()) vchData.resize(nPos);
     }
 
 private:
     const int nType;
     const int nVersion;
     std::vector<uint8_t> &vchData;
     size_t nPos;
 };
 
 /**
  * Minimal stream for reading from an existing vector by reference
  */
 class VectorReader {
 private:
     const int m_type;
     const int m_version;
     const std::vector<uint8_t> &m_data;
     size_t m_pos = 0;
 
 public:
     /**
      * @param[in]  type Serialization Type
      * @param[in]  version Serialization Version (including any flags)
      * @param[in]  data Referenced byte vector to overwrite/append
      * @param[in]  pos Starting position. Vector index where reads should start.
      */
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos)
         : m_type(type), m_version(version), m_data(data), m_pos(pos) {
         if (m_pos > m_data.size()) {
             throw std::ios_base::failure(
                 "VectorReader(...): end of data (m_pos > m_data.size())");
         }
     }
 
     /**
      * (other params same as above)
      * @param[in]  args  A list of items to deserialize starting at pos.
      */
     template <typename... Args>
     VectorReader(int type, int version, const std::vector<uint8_t> &data,
                  size_t pos, Args &&... args)
         : VectorReader(type, version, data, pos) {
         ::UnserializeMany(*this, std::forward<Args>(args)...);
     }
 
     template <typename T> VectorReader &operator>>(T &obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     int GetVersion() const { return m_version; }
     int GetType() const { return m_type; }
 
     size_t size() const { return m_data.size() - m_pos; }
     bool empty() const { return m_data.size() == m_pos; }
 
     void read(char *dst, size_t n) {
         if (n == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         size_t pos_next = m_pos + n;
         if (pos_next > m_data.size()) {
             throw std::ios_base::failure("VectorReader::read(): end of data");
         }
         memcpy(dst, m_data.data() + m_pos, n);
         m_pos = pos_next;
     }
 };
 
 /**
  * Double ended buffer combining vector and stream-like interfaces.
  *
  * >> and << read and write unformatted data using the above serialization
  * templates. Fills with data in linear time; some stringstream implementations
  * take N^2 time.
  */
 class CDataStream {
 protected:
     typedef CSerializeData vector_type;
     vector_type vch;
     unsigned int nReadPos;
 
     int nType;
     int nVersion;
 
 public:
     typedef vector_type::allocator_type allocator_type;
     typedef vector_type::size_type size_type;
     typedef vector_type::difference_type difference_type;
     typedef vector_type::reference reference;
     typedef vector_type::const_reference const_reference;
     typedef vector_type::value_type value_type;
     typedef vector_type::iterator iterator;
     typedef vector_type::const_iterator const_iterator;
     typedef vector_type::reverse_iterator reverse_iterator;
 
     explicit CDataStream(int nTypeIn, int nVersionIn) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn,
                 int nVersionIn)
         : vch(pbegin, pend) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const char *pbegin, const char *pend, int nTypeIn,
                 int nVersionIn)
         : vch(pbegin, pend) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const vector_type &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const std::vector<char> &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     CDataStream(const std::vector<uint8_t> &vchIn, int nTypeIn, int nVersionIn)
         : vch(vchIn.begin(), vchIn.end()) {
         Init(nTypeIn, nVersionIn);
     }
 
     template <typename... Args>
     CDataStream(int nTypeIn, int nVersionIn, Args &&... args) {
         Init(nTypeIn, nVersionIn);
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
 
     void Init(int nTypeIn, int nVersionIn) {
         nReadPos = 0;
         nType = nTypeIn;
         nVersion = nVersionIn;
     }
 
     CDataStream &operator+=(const CDataStream &b) {
         vch.insert(vch.end(), b.begin(), b.end());
         return *this;
     }
 
     friend CDataStream operator+(const CDataStream &a, const CDataStream &b) {
         CDataStream ret = a;
         ret += b;
         return (ret);
     }
 
     std::string str() const { return (std::string(begin(), end())); }
 
     //
     // Vector subset
     //
     const_iterator begin() const { return vch.begin() + nReadPos; }
     iterator begin() { return vch.begin() + nReadPos; }
     const_iterator end() const { return vch.end(); }
     iterator end() { return vch.end(); }
     size_type size() const { return vch.size() - nReadPos; }
     bool empty() const { return vch.size() == nReadPos; }
     void resize(size_type n, value_type c = 0) { vch.resize(n + nReadPos, c); }
     void reserve(size_type n) { vch.reserve(n + nReadPos); }
     const_reference operator[](size_type pos) const {
         return vch[pos + nReadPos];
     }
     reference operator[](size_type pos) { return vch[pos + nReadPos]; }
     void clear() {
         vch.clear();
         nReadPos = 0;
     }
     iterator insert(iterator it, const char x = char()) {
         return vch.insert(it, x);
     }
     void insert(iterator it, size_type n, const char x) {
         vch.insert(it, n, x);
     }
     value_type *data() { return vch.data() + nReadPos; }
     const value_type *data() const { return vch.data() + nReadPos; }
 
     void insert(iterator it, std::vector<char>::const_iterator first,
                 std::vector<char>::const_iterator last) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     void insert(iterator it, const char *first, const char *last) {
         if (last == first) {
             return;
         }
 
         assert(last - first > 0);
         if (it == vch.begin() + nReadPos &&
             (unsigned int)(last - first) <= nReadPos) {
             // special case for inserting at the front when there's room
             nReadPos -= (last - first);
             memcpy(&vch[nReadPos], &first[0], last - first);
         } else {
             vch.insert(it, first, last);
         }
     }
 
     iterator erase(iterator it) {
         if (it == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (++nReadPos >= vch.size()) {
                 // whenever we reach the end, we take the opportunity to clear
                 // the buffer
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             }
             return vch.begin() + nReadPos;
         } else {
             return vch.erase(it);
         }
     }
 
     iterator erase(iterator first, iterator last) {
         if (first == vch.begin() + nReadPos) {
             // special case for erasing from the front
             if (last == vch.end()) {
                 nReadPos = 0;
                 return vch.erase(vch.begin(), vch.end());
             } else {
                 nReadPos = (last - vch.begin());
                 return last;
             }
         } else
             return vch.erase(first, last);
     }
 
     inline void Compact() {
         vch.erase(vch.begin(), vch.begin() + nReadPos);
         nReadPos = 0;
     }
 
     bool Rewind(size_type n) {
         // Rewind by n characters if the buffer hasn't been compacted yet
         if (n > nReadPos) return false;
         nReadPos -= n;
         return true;
     }
 
     //
     // Stream subset
     //
     bool eof() const { return size() == 0; }
     CDataStream *rdbuf() { return this; }
     int in_avail() const { return size(); }
 
     void SetType(int n) { nType = n; }
     int GetType() const { return nType; }
     void SetVersion(int n) { nVersion = n; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (nSize == 0) {
             return;
         }
 
         // Read from the beginning of the buffer
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext > vch.size()) {
             throw std::ios_base::failure("CDataStream::read(): end of data");
         }
         memcpy(pch, &vch[nReadPos], nSize);
         if (nReadPosNext == vch.size()) {
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void ignore(int nSize) {
         // Ignore from the beginning of the buffer
         if (nSize < 0) {
             throw std::ios_base::failure(
                 "CDataStream::ignore(): nSize negative");
         }
         unsigned int nReadPosNext = nReadPos + nSize;
         if (nReadPosNext >= vch.size()) {
             if (nReadPosNext > vch.size())
                 throw std::ios_base::failure(
                     "CDataStream::ignore(): end of data");
             nReadPos = 0;
             vch.clear();
             return;
         }
         nReadPos = nReadPosNext;
     }
 
     void write(const char *pch, size_t nSize) {
         // Write to the end of the buffer
         vch.insert(vch.end(), pch, pch + nSize);
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         // Special case: stream << stream concatenates like stream += stream
-        if (!vch.empty()) s.write((char *)&vch[0], vch.size() * sizeof(vch[0]));
+        if (!vch.empty()) {
+            s.write((char *)vch.data(), vch.size() * sizeof(value_type));
+        }
     }
 
     template <typename T> CDataStream &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> CDataStream &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     void GetAndClear(CSerializeData &d) {
         d.insert(d.end(), begin(), end());
         clear();
     }
 
     /**
      * XOR the contents of this stream with a certain key.
      *
      * @param[in] key    The key used to XOR the data in this stream.
      */
     void Xor(const std::vector<uint8_t> &key) {
         if (key.size() == 0) {
             return;
         }
 
         for (size_type i = 0, j = 0; i != size(); i++) {
             vch[i] ^= key[j++];
 
             // This potentially acts on very many bytes of data, so it's
             // important that we calculate `j`, i.e. the `key` index in this way
             // instead of doing a %, which would effectively be a division for
             // each byte Xor'd -- much slower than need be.
             if (j == key.size()) j = 0;
         }
     }
 };
 
 template <typename IStream> class BitStreamReader {
 private:
     IStream &m_istream;
 
     /// Buffered byte read in from the input stream. A new byte is read into the
     /// buffer when m_offset reaches 8.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already returned by previous
     /// Read() calls. The next bit to be returned is at this offset from the
     /// most significant bit position.
     int m_offset{8};
 
 public:
     explicit BitStreamReader(IStream &istream) : m_istream(istream) {}
 
     /**
      * Read the specified number of bits from the stream. The data is returned
      * in the nbits least significant bits of a 64-bit uint.
      */
     uint64_t Read(int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         uint64_t data = 0;
         while (nbits > 0) {
             if (m_offset == 8) {
                 m_istream >> m_buffer;
                 m_offset = 0;
             }
 
             int bits = std::min(8 - m_offset, nbits);
             data <<= bits;
             data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
             m_offset += bits;
             nbits -= bits;
         }
         return data;
     }
 };
 
 template <typename OStream> class BitStreamWriter {
 private:
     OStream &m_ostream;
 
     /// Buffered byte waiting to be written to the output stream. The byte is
     /// written buffer when m_offset reaches 8 or Flush() is called.
     uint8_t m_buffer{0};
 
     /// Number of high order bits in m_buffer already written by previous
     /// Write() calls and not yet flushed to the stream. The next bit to be
     /// written to is at this offset from the most significant bit position.
     int m_offset{0};
 
 public:
     explicit BitStreamWriter(OStream &ostream) : m_ostream(ostream) {}
 
     ~BitStreamWriter() { Flush(); }
 
     /**
      * Write the nbits least significant bits of a 64-bit int to the output
      * stream. Data is buffered until it completes an octet.
      */
     void Write(uint64_t data, int nbits) {
         if (nbits < 0 || nbits > 64) {
             throw std::out_of_range("nbits must be between 0 and 64");
         }
 
         while (nbits > 0) {
             int bits = std::min(8 - m_offset, nbits);
             m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
             m_offset += bits;
             nbits -= bits;
 
             if (m_offset == 8) {
                 Flush();
             }
         }
     }
 
     /**
      * Flush any unwritten bits to the output stream, padding with 0's to the
      * next byte boundary.
      */
     void Flush() {
         if (m_offset == 0) {
             return;
         }
 
         m_ostream << m_buffer;
         m_buffer = 0;
         m_offset = 0;
     }
 };
 
 /**
  * Non-refcounted RAII wrapper for FILE*
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you're returning the file pointer, return file.release(). If you need to
  * close the file early, use file.fclose() instead of fclose(file).
  */
 class CAutoFile {
 private:
     const int nType;
     const int nVersion;
 
     FILE *file;
 
 public:
     CAutoFile(FILE *filenew, int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn) {
         file = filenew;
     }
 
     ~CAutoFile() { fclose(); }
 
     // Disallow copies
     CAutoFile(const CAutoFile &) = delete;
     CAutoFile &operator=(const CAutoFile &) = delete;
 
     void fclose() {
         if (file) {
             ::fclose(file);
             file = nullptr;
         }
     }
 
     /**
      * Get wrapped FILE* with transfer of ownership.
      * @note This will invalidate the CAutoFile object, and makes it the
      * responsibility of the caller of this function to clean up the returned
      * FILE*.
      */
     FILE *release() {
         FILE *ret = file;
         file = nullptr;
         return ret;
     }
 
     /**
      * Get wrapped FILE* without transfer of ownership.
      * @note Ownership of the FILE* will remain with this class. Use this only
      * if the scope of the CAutoFile outlives use of the passed pointer.
      */
     FILE *Get() const { return file; }
 
     /** Return true if the wrapped FILE* is nullptr, false otherwise. */
     bool IsNull() const { return (file == nullptr); }
 
     //
     // Stream subset
     //
     int GetType() const { return nType; }
     int GetVersion() const { return nVersion; }
 
     void read(char *pch, size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::read: file handle is nullptr");
         if (fread(pch, 1, nSize, file) != nSize)
             throw std::ios_base::failure(feof(file)
                                              ? "CAutoFile::read: end of file"
                                              : "CAutoFile::read: fread failed");
     }
 
     void ignore(size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::ignore: file handle is nullptr");
         uint8_t data[4096];
         while (nSize > 0) {
             size_t nNow = std::min<size_t>(nSize, sizeof(data));
             if (fread(data, 1, nNow, file) != nNow)
                 throw std::ios_base::failure(
                     feof(file) ? "CAutoFile::ignore: end of file"
                                : "CAutoFile::read: fread failed");
             nSize -= nNow;
         }
     }
 
     void write(const char *pch, size_t nSize) {
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::write: file handle is nullptr");
         if (fwrite(pch, 1, nSize, file) != nSize)
             throw std::ios_base::failure("CAutoFile::write: write failed");
     }
 
     template <typename T> CAutoFile &operator<<(const T &obj) {
         // Serialize to this stream
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::operator<<: file handle is nullptr");
         ::Serialize(*this, obj);
         return (*this);
     }
 
     template <typename T> CAutoFile &operator>>(T &&obj) {
         // Unserialize from this stream
         if (!file)
             throw std::ios_base::failure(
                 "CAutoFile::operator>>: file handle is nullptr");
         ::Unserialize(*this, obj);
         return (*this);
     }
 };
 
 /**
  * Non-refcounted RAII wrapper around a FILE* that implements a ring buffer to
  * deserialize from. It guarantees the ability to rewind a given number of
  * bytes.
  *
  * Will automatically close the file when it goes out of scope if not null. If
  * you need to close the file early, use file.fclose() instead of fclose(file).
  */
 class CBufferedFile {
 private:
     const int nType;
     const int nVersion;
 
     // source file
     FILE *src;
     // how many bytes have been read from source
     uint64_t nSrcPos;
     // how many bytes have been read from this
     uint64_t nReadPos;
     // up to which position we're allowed to read
     uint64_t nReadLimit;
     // how many bytes we guarantee to rewind
     uint64_t nRewind;
     // the buffer
     std::vector<char> vchBuf;
 
 protected:
     // read data from the source to fill the buffer
     bool Fill() {
         unsigned int pos = nSrcPos % vchBuf.size();
         unsigned int readNow = vchBuf.size() - pos;
         unsigned int nAvail = vchBuf.size() - (nSrcPos - nReadPos) - nRewind;
         if (nAvail < readNow) readNow = nAvail;
         if (readNow == 0) return false;
         size_t nBytes = fread((void *)&vchBuf[pos], 1, readNow, src);
         if (nBytes == 0) {
             throw std::ios_base::failure(
                 feof(src) ? "CBufferedFile::Fill: end of file"
                           : "CBufferedFile::Fill: fread failed");
         } else {
             nSrcPos += nBytes;
             return true;
         }
     }
 
 public:
     CBufferedFile(FILE *fileIn, uint64_t nBufSize, uint64_t nRewindIn,
                   int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn), nSrcPos(0), nReadPos(0),
           nReadLimit((uint64_t)(-1)), nRewind(nRewindIn), vchBuf(nBufSize, 0) {
         src = fileIn;
     }
 
     ~CBufferedFile() { fclose(); }
 
     // Disallow copies
     CBufferedFile(const CBufferedFile &) = delete;
     CBufferedFile &operator=(const CBufferedFile &) = delete;
 
     int GetVersion() const { return nVersion; }
     int GetType() const { return nType; }
 
     void fclose() {
         if (src) {
             ::fclose(src);
             src = nullptr;
         }
     }
 
     // check whether we're at the end of the source file
     bool eof() const { return nReadPos == nSrcPos && feof(src); }
 
     // read a number of bytes
     void read(char *pch, size_t nSize) {
         if (nSize + nReadPos > nReadLimit)
             throw std::ios_base::failure("Read attempted past buffer limit");
         if (nSize + nRewind > vchBuf.size())
             throw std::ios_base::failure("Read larger than buffer size");
         while (nSize > 0) {
             if (nReadPos == nSrcPos) Fill();
             unsigned int pos = nReadPos % vchBuf.size();
             size_t nNow = nSize;
             if (nNow + pos > vchBuf.size()) nNow = vchBuf.size() - pos;
             if (nNow + nReadPos > nSrcPos) nNow = nSrcPos - nReadPos;
             memcpy(pch, &vchBuf[pos], nNow);
             nReadPos += nNow;
             pch += nNow;
             nSize -= nNow;
         }
     }
 
     // return the current reading position
     uint64_t GetPos() const { return nReadPos; }
 
     // rewind to a given reading position
     bool SetPos(uint64_t nPos) {
         nReadPos = nPos;
         if (nReadPos + nRewind < nSrcPos) {
             nReadPos = nSrcPos - nRewind;
             return false;
         } else if (nReadPos > nSrcPos) {
             nReadPos = nSrcPos;
             return false;
         } else {
             return true;
         }
     }
 
     bool Seek(uint64_t nPos) {
         long nLongPos = nPos;
         if (nPos != (uint64_t)nLongPos) return false;
         if (fseek(src, nLongPos, SEEK_SET)) return false;
         nLongPos = ftell(src);
         nSrcPos = nLongPos;
         nReadPos = nLongPos;
         return true;
     }
 
     // Prevent reading beyond a certain position. No argument removes the limit.
     bool SetLimit(uint64_t nPos = (uint64_t)(-1)) {
         if (nPos < nReadPos) return false;
         nReadLimit = nPos;
         return true;
     }
 
     template <typename T> CBufferedFile &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 
     // search for a given byte in the stream, and remain positioned on it
     void FindByte(char ch) {
         while (true) {
             if (nReadPos == nSrcPos) Fill();
             if (vchBuf[nReadPos % vchBuf.size()] == ch) break;
             nReadPos++;
         }
     }
 };
 
 #endif // BITCOIN_STREAMS_H
diff --git a/src/utilstrencodings.cpp b/src/utilstrencodings.cpp
index db00a6036..ef8020ffb 100644
--- a/src/utilstrencodings.cpp
+++ b/src/utilstrencodings.cpp
@@ -1,817 +1,813 @@
 // 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.
 
 #include <utilstrencodings.h>
 
 #include <tinyformat.h>
 
 #include <algorithm>
 #include <cerrno>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 
 static const std::string CHARS_ALPHA_NUM =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 static const std::string SAFE_CHARS[] = {
     // SAFE_CHARS_DEFAULT
     CHARS_ALPHA_NUM + " .,;-_/:?@()",
     // SAFE_CHARS_UA_COMMENT
     CHARS_ALPHA_NUM + " .,;-_?@",
     // SAFE_CHARS_FILENAME
     CHARS_ALPHA_NUM + ".-_",
 };
 
 std::string SanitizeString(const std::string &str, int rule) {
     std::string strResult;
     for (std::string::size_type i = 0; i < str.size(); i++) {
         if (SAFE_CHARS[rule].find(str[i]) != std::string::npos) {
             strResult.push_back(str[i]);
         }
     }
     return strResult;
 }
 
 const signed char p_util_hexdigit[256] = {
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     0,  1,   2,   3,   4,   5,   6,   7,  8,  9,  -1, -1, -1, -1, -1, -1,
     -1, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1,  -1,  -1,  -1,  -1,  -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
 };
 
 signed char HexDigit(char c) {
     return p_util_hexdigit[(uint8_t)c];
 }
 
 bool IsHex(const std::string &str) {
     for (std::string::const_iterator it(str.begin()); it != str.end(); ++it) {
         if (HexDigit(*it) < 0) {
             return false;
         }
     }
     return (str.size() > 0) && (str.size() % 2 == 0);
 }
 
 bool IsHexNumber(const std::string &str) {
     size_t starting_location = 0;
     if (str.size() > 2 && *str.begin() == '0' && *(str.begin() + 1) == 'x') {
         starting_location = 2;
     }
     for (auto c : str.substr(starting_location)) {
         if (HexDigit(c) < 0) {
             return false;
         }
     }
     // Return false for empty string or "0x".
     return (str.size() > starting_location);
 }
 
 std::vector<uint8_t> ParseHex(const char *psz) {
     // convert hex dump to vector
     std::vector<uint8_t> vch;
     while (true) {
         while (IsSpace(*psz)) {
             psz++;
         }
         signed char c = HexDigit(*psz++);
         if (c == (signed char)-1) {
             break;
         }
         uint8_t n = (c << 4);
         c = HexDigit(*psz++);
         if (c == (signed char)-1) {
             break;
         }
         n |= c;
         vch.push_back(n);
     }
     return vch;
 }
 
 std::vector<uint8_t> ParseHex(const std::string &str) {
     return ParseHex(str.c_str());
 }
 
 void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
     size_t colon = in.find_last_of(':');
     // if a : is found, and it either follows a [...], or no other : is in the
     // string, treat it as port separator
     bool fHaveColon = colon != in.npos;
     bool fBracketed =
         fHaveColon &&
         (in[0] == '[' && in[colon - 1] == ']'); // if there is a colon, and
                                                 // in[0]=='[', colon is not 0,
                                                 // so in[colon-1] is safe
     bool fMultiColon =
         fHaveColon && (in.find_last_of(':', colon - 1) != in.npos);
     if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) {
         int32_t n;
         if (ParseInt32(in.substr(colon + 1), &n) && n > 0 && n < 0x10000) {
             in = in.substr(0, colon);
             portOut = n;
         }
     }
     if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']') {
         hostOut = in.substr(1, in.size() - 2);
     } else {
         hostOut = in;
     }
 }
 
 std::string EncodeBase64(const uint8_t *pch, size_t len) {
     static const char *pbase64 =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
     std::string strRet = "";
     strRet.reserve((len + 2) / 3 * 4);
 
     int mode = 0, left = 0;
     const uint8_t *pchEnd = pch + len;
 
     while (pch < pchEnd) {
         int enc = *(pch++);
         switch (mode) {
             case 0: // we have no bits
                 strRet += pbase64[enc >> 2];
                 left = (enc & 3) << 4;
                 mode = 1;
                 break;
 
             case 1: // we have two bits
                 strRet += pbase64[left | (enc >> 4)];
                 left = (enc & 15) << 2;
                 mode = 2;
                 break;
 
             case 2: // we have four bits
                 strRet += pbase64[left | (enc >> 6)];
                 strRet += pbase64[enc & 63];
                 mode = 0;
                 break;
         }
     }
 
     if (mode) {
         strRet += pbase64[left];
         strRet += '=';
         if (mode == 1) {
             strRet += '=';
         }
     }
 
     return strRet;
 }
 
 std::string EncodeBase64(const std::string &str) {
     return EncodeBase64((const uint8_t *)str.c_str(), str.size());
 }
 
 std::vector<uint8_t> DecodeBase64(const char *p, bool *pfInvalid) {
     static const int decode64_table[256] = {
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57,
         58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,
         7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
         25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
         37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1};
 
     if (pfInvalid) {
         *pfInvalid = false;
     }
 
     std::vector<uint8_t> vchRet;
     vchRet.reserve(strlen(p) * 3 / 4);
 
     int mode = 0;
     int left = 0;
 
     while (1) {
         int dec = decode64_table[(uint8_t)*p];
         if (dec == -1) {
             break;
         }
         p++;
         switch (mode) {
             case 0: // we have no bits and get 6
                 left = dec;
                 mode = 1;
                 break;
 
             case 1: // we have 6 bits and keep 4
                 vchRet.push_back((left << 2) | (dec >> 4));
                 left = dec & 15;
                 mode = 2;
                 break;
 
             case 2: // we have 4 bits and get 6, we keep 2
                 vchRet.push_back((left << 4) | (dec >> 2));
                 left = dec & 3;
                 mode = 3;
                 break;
 
             case 3: // we have 2 bits and get 6
                 vchRet.push_back((left << 6) | dec);
                 mode = 0;
                 break;
         }
     }
 
     if (pfInvalid) {
         switch (mode) {
             case 0: // 4n base64 characters processed: ok
                 break;
 
             case 1: // 4n+1 base64 character processed: impossible
                 *pfInvalid = true;
                 break;
 
             case 2: // 4n+2 base64 characters processed: require '=='
                 if (left || p[0] != '=' || p[1] != '=' ||
                     decode64_table[(uint8_t)p[2]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
 
             case 3: // 4n+3 base64 characters processed: require '='
                 if (left || p[0] != '=' ||
                     decode64_table[(uint8_t)p[1]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
         }
     }
 
     return vchRet;
 }
 
 std::string DecodeBase64(const std::string &str) {
     std::vector<uint8_t> vchRet = DecodeBase64(str.c_str());
-    return (vchRet.size() == 0)
-               ? std::string()
-               : std::string((const char *)&vchRet[0], vchRet.size());
+    return std::string((const char *)vchRet.data(), vchRet.size());
 }
 
 std::string EncodeBase32(const uint8_t *pch, size_t len) {
     static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
 
     std::string strRet = "";
     strRet.reserve((len + 4) / 5 * 8);
 
     int mode = 0, left = 0;
     const uint8_t *pchEnd = pch + len;
 
     while (pch < pchEnd) {
         int enc = *(pch++);
         switch (mode) {
             case 0: // we have no bits
                 strRet += pbase32[enc >> 3];
                 left = (enc & 7) << 2;
                 mode = 1;
                 break;
 
             case 1: // we have three bits
                 strRet += pbase32[left | (enc >> 6)];
                 strRet += pbase32[(enc >> 1) & 31];
                 left = (enc & 1) << 4;
                 mode = 2;
                 break;
 
             case 2: // we have one bit
                 strRet += pbase32[left | (enc >> 4)];
                 left = (enc & 15) << 1;
                 mode = 3;
                 break;
 
             case 3: // we have four bits
                 strRet += pbase32[left | (enc >> 7)];
                 strRet += pbase32[(enc >> 2) & 31];
                 left = (enc & 3) << 3;
                 mode = 4;
                 break;
 
             case 4: // we have two bits
                 strRet += pbase32[left | (enc >> 5)];
                 strRet += pbase32[enc & 31];
                 mode = 0;
         }
     }
 
     static const int nPadding[5] = {0, 6, 4, 3, 1};
     if (mode) {
         strRet += pbase32[left];
         for (int n = 0; n < nPadding[mode]; n++) {
             strRet += '=';
         }
     }
 
     return strRet;
 }
 
 std::string EncodeBase32(const std::string &str) {
     return EncodeBase32((const uint8_t *)str.c_str(), str.size());
 }
 
 std::vector<uint8_t> DecodeBase32(const char *p, bool *pfInvalid) {
     static const int decode32_table[256] = {
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
         30, 31, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,
         7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
         25, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
         11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1};
 
     if (pfInvalid) {
         *pfInvalid = false;
     }
 
     std::vector<uint8_t> vchRet;
     vchRet.reserve((strlen(p)) * 5 / 8);
 
     int mode = 0;
     int left = 0;
 
     while (1) {
         int dec = decode32_table[(uint8_t)*p];
         if (dec == -1) {
             break;
         }
         p++;
         switch (mode) {
             case 0: // we have no bits and get 5
                 left = dec;
                 mode = 1;
                 break;
 
             case 1: // we have 5 bits and keep 2
                 vchRet.push_back((left << 3) | (dec >> 2));
                 left = dec & 3;
                 mode = 2;
                 break;
 
             case 2: // we have 2 bits and keep 7
                 left = left << 5 | dec;
                 mode = 3;
                 break;
 
             case 3: // we have 7 bits and keep 4
                 vchRet.push_back((left << 1) | (dec >> 4));
                 left = dec & 15;
                 mode = 4;
                 break;
 
             case 4: // we have 4 bits, and keep 1
                 vchRet.push_back((left << 4) | (dec >> 1));
                 left = dec & 1;
                 mode = 5;
                 break;
 
             case 5: // we have 1 bit, and keep 6
                 left = left << 5 | dec;
                 mode = 6;
                 break;
 
             case 6: // we have 6 bits, and keep 3
                 vchRet.push_back((left << 2) | (dec >> 3));
                 left = dec & 7;
                 mode = 7;
                 break;
 
             case 7: // we have 3 bits, and keep 0
                 vchRet.push_back((left << 5) | dec);
                 mode = 0;
                 break;
         }
     }
 
     if (pfInvalid) switch (mode) {
             case 0: // 8n base32 characters processed: ok
                 break;
 
             case 1: // 8n+1 base32 characters processed: impossible
             case 3: //   +3
             case 6: //   +6
                 *pfInvalid = true;
                 break;
 
             case 2: // 8n+2 base32 characters processed: require '======'
                 if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' ||
                     p[3] != '=' || p[4] != '=' || p[5] != '=' ||
                     decode32_table[(uint8_t)p[6]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
 
             case 4: // 8n+4 base32 characters processed: require '===='
                 if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' ||
                     p[3] != '=' || decode32_table[(uint8_t)p[4]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
 
             case 5: // 8n+5 base32 characters processed: require '==='
                 if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' ||
                     decode32_table[(uint8_t)p[3]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
 
             case 7: // 8n+7 base32 characters processed: require '='
                 if (left || p[0] != '=' ||
                     decode32_table[(uint8_t)p[1]] != -1) {
                     *pfInvalid = true;
                 }
                 break;
         }
 
     return vchRet;
 }
 
 std::string DecodeBase32(const std::string &str) {
     std::vector<uint8_t> vchRet = DecodeBase32(str.c_str());
-    return (vchRet.size() == 0)
-               ? std::string()
-               : std::string((const char *)&vchRet[0], vchRet.size());
+    return std::string((const char *)vchRet.data(), vchRet.size());
 }
 
 static bool ParsePrechecks(const std::string &str) {
     // No empty string allowed
     if (str.empty()) {
         return false;
     }
     // No padding allowed
     if (str.size() >= 1 && (IsSpace(str[0]) || IsSpace(str[str.size() - 1]))) {
         return false;
     }
     // No embedded NUL characters allowed
     if (str.size() != strlen(str.c_str())) {
         return false;
     }
     return true;
 }
 
 bool ParseInt32(const std::string &str, int32_t *out) {
     if (!ParsePrechecks(str)) {
         return false;
     }
     char *endp = nullptr;
     // strtol will not set errno if valid
     errno = 0;
     long int n = strtol(str.c_str(), &endp, 10);
     if (out) {
         *out = (int32_t)n;
     }
     // Note that strtol returns a *long int*, so even if strtol doesn't report a
     // over/underflow we still have to check that the returned value is within
     // the range of an *int32_t*. On 64-bit platforms the size of these types
     // may be different.
     return endp && *endp == 0 && !errno &&
            n >= std::numeric_limits<int32_t>::min() &&
            n <= std::numeric_limits<int32_t>::max();
 }
 
 bool ParseInt64(const std::string &str, int64_t *out) {
     if (!ParsePrechecks(str)) {
         return false;
     }
     char *endp = nullptr;
     // strtoll will not set errno if valid
     errno = 0;
     long long int n = strtoll(str.c_str(), &endp, 10);
     if (out) {
         *out = (int64_t)n;
     }
     // Note that strtoll returns a *long long int*, so even if strtol doesn't
     // report a over/underflow we still have to check that the returned value is
     // within the range of an *int64_t*.
     return endp && *endp == 0 && !errno &&
            n >= std::numeric_limits<int64_t>::min() &&
            n <= std::numeric_limits<int64_t>::max();
 }
 
 bool ParseUInt32(const std::string &str, uint32_t *out) {
     if (!ParsePrechecks(str)) {
         return false;
     }
     // Reject negative values, unfortunately strtoul accepts these by default if
     // they fit in the range
     if (str.size() >= 1 && str[0] == '-') {
         return false;
     }
     char *endp = nullptr;
     // strtoul will not set errno if valid
     errno = 0;
     unsigned long int n = strtoul(str.c_str(), &endp, 10);
     if (out) {
         *out = (uint32_t)n;
     }
     // Note that strtoul returns a *unsigned long int*, so even if it doesn't
     // report a over/underflow we still have to check that the returned value is
     // within the range of an *uint32_t*. On 64-bit platforms the size of these
     // types may be different.
     return endp && *endp == 0 && !errno &&
            n <= std::numeric_limits<uint32_t>::max();
 }
 
 bool ParseUInt64(const std::string &str, uint64_t *out) {
     if (!ParsePrechecks(str)) {
         return false;
     }
     // Reject negative values, unfortunately strtoull accepts these by default
     // if they fit in the range
     if (str.size() >= 1 && str[0] == '-') {
         return false;
     }
     char *endp = nullptr;
     // strtoull will not set errno if valid
     errno = 0;
     unsigned long long int n = strtoull(str.c_str(), &endp, 10);
     if (out) {
         *out = (uint64_t)n;
     }
     // Note that strtoull returns a *unsigned long long int*, so even if it
     // doesn't report a over/underflow we still have to check that the returned
     // value is within the range of an *uint64_t*.
     return endp && *endp == 0 && !errno &&
            n <= std::numeric_limits<uint64_t>::max();
 }
 
 bool ParseDouble(const std::string &str, double *out) {
     if (!ParsePrechecks(str)) {
         return false;
     }
     // No hexadecimal floats allowed
     if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') {
         return false;
     }
     std::istringstream text(str);
     text.imbue(std::locale::classic());
     double result;
     text >> result;
     if (out) {
         *out = result;
     }
     return text.eof() && !text.fail();
 }
 
 std::string FormatParagraph(const std::string &in, size_t width,
                             size_t indent) {
     std::stringstream out;
     size_t ptr = 0;
     size_t indented = 0;
     while (ptr < in.size()) {
         size_t lineend = in.find_first_of('\n', ptr);
         if (lineend == std::string::npos) {
             lineend = in.size();
         }
         const size_t linelen = lineend - ptr;
         const size_t rem_width = width - indented;
         if (linelen <= rem_width) {
             out << in.substr(ptr, linelen + 1);
             ptr = lineend + 1;
             indented = 0;
         } else {
             size_t finalspace = in.find_last_of(" \n", ptr + rem_width);
             if (finalspace == std::string::npos || finalspace < ptr) {
                 // No place to break; just include the entire word and move on
                 finalspace = in.find_first_of("\n ", ptr);
                 if (finalspace == std::string::npos) {
                     // End of the string, just add it and break
                     out << in.substr(ptr);
                     break;
                 }
             }
             out << in.substr(ptr, finalspace - ptr) << "\n";
             if (in[finalspace] == '\n') {
                 indented = 0;
             } else if (indent) {
                 out << std::string(indent, ' ');
                 indented = indent;
             }
             ptr = finalspace + 1;
         }
     }
     return out.str();
 }
 
 std::string i64tostr(int64_t n) {
     return strprintf("%d", n);
 }
 
 std::string itostr(int n) {
     return strprintf("%d", n);
 }
 
 int64_t atoi64(const char *psz) {
 #ifdef _MSC_VER
     return _atoi64(psz);
 #else
     return strtoll(psz, nullptr, 10);
 #endif
 }
 
 int64_t atoi64(const std::string &str) {
 #ifdef _MSC_VER
     return _atoi64(str.c_str());
 #else
     return strtoll(str.c_str(), nullptr, 10);
 #endif
 }
 
 int atoi(const std::string &str) {
     return atoi(str.c_str());
 }
 
 /**
  * Upper bound for mantissa.
  * 10^18-1 is the largest arbitrary decimal that will fit in a signed 64-bit
  * integer. Larger integers cannot consist of arbitrary combinations of 0-9:
  *
  *   999999999999999999  1^18-1
  *  9223372036854775807  (1<<63)-1  (max int64_t)
  *  9999999999999999999  1^19-1     (would overflow)
  */
 static const int64_t UPPER_BOUND = 1000000000000000000LL - 1LL;
 
 /** Helper function for ParseFixedPoint */
 static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa,
                                         int &mantissa_tzeros) {
     if (ch == '0') {
         ++mantissa_tzeros;
     } else {
         for (int i = 0; i <= mantissa_tzeros; ++i) {
             // overflow
             if (mantissa > (UPPER_BOUND / 10LL)) {
                 return false;
             }
             mantissa *= 10;
         }
         mantissa += ch - '0';
         mantissa_tzeros = 0;
     }
     return true;
 }
 
 bool ParseFixedPoint(const std::string &val, int decimals,
                      int64_t *amount_out) {
     int64_t mantissa = 0;
     int64_t exponent = 0;
     int mantissa_tzeros = 0;
     bool mantissa_sign = false;
     bool exponent_sign = false;
     int ptr = 0;
     int end = val.size();
     int point_ofs = 0;
 
     if (ptr < end && val[ptr] == '-') {
         mantissa_sign = true;
         ++ptr;
     }
     if (ptr < end) {
         if (val[ptr] == '0') {
             // pass single 0
             ++ptr;
         } else if (val[ptr] >= '1' && val[ptr] <= '9') {
             while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
                 if (!ProcessMantissaDigit(val[ptr], mantissa,
                                           mantissa_tzeros)) {
                     // overflow
                     return false;
                 }
                 ++ptr;
             }
         } else {
             // missing expected digit
             return false;
         }
     } else {
         // empty string or loose '-'
         return false;
     }
     if (ptr < end && val[ptr] == '.') {
         ++ptr;
         if (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
             while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
                 if (!ProcessMantissaDigit(val[ptr], mantissa,
                                           mantissa_tzeros)) {
                     // overflow
                     return false;
                 }
                 ++ptr;
                 ++point_ofs;
             }
         } else {
             // missing expected digit
             return false;
         }
     }
     if (ptr < end && (val[ptr] == 'e' || val[ptr] == 'E')) {
         ++ptr;
         if (ptr < end && val[ptr] == '+') {
             ++ptr;
         } else if (ptr < end && val[ptr] == '-') {
             exponent_sign = true;
             ++ptr;
         }
         if (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
             while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
                 if (exponent > (UPPER_BOUND / 10LL)) {
                     // overflow
                     return false;
                 }
                 exponent = exponent * 10 + val[ptr] - '0';
                 ++ptr;
             }
         } else {
             // missing expected digit
             return false;
         }
     }
     if (ptr != end) {
         // trailing garbage
         return false;
     }
     // finalize exponent
     if (exponent_sign) {
         exponent = -exponent;
     }
     exponent = exponent - point_ofs + mantissa_tzeros;
 
     // finalize mantissa
     if (mantissa_sign) {
         mantissa = -mantissa;
     }
 
     // convert to one 64-bit fixed-point value
     exponent += decimals;
     if (exponent < 0) {
         // cannot represent values smaller than 10^-decimals
         return false;
     }
     if (exponent >= 18) {
         // cannot represent values larger than or equal to 10^(18-decimals)
         return false;
     }
 
     for (int i = 0; i < exponent; ++i) {
         if (mantissa > (UPPER_BOUND / 10LL) ||
             mantissa < -(UPPER_BOUND / 10LL)) {
             // overflow
             return false;
         }
         mantissa *= 10;
     }
     if (mantissa > UPPER_BOUND || mantissa < -UPPER_BOUND) {
         // overflow
         return false;
     }
 
     if (amount_out) {
         *amount_out = mantissa;
     }
 
     return true;
 }
 
 void Downcase(std::string &str) {
     std::transform(str.begin(), str.end(), str.begin(),
                    [](unsigned char c) { return ToLower(c); });
 }
 
 std::string Capitalize(std::string str) {
     if (str.empty()) return str;
     str[0] = ToUpper(str.front());
     return str;
 }