diff --git a/src/hash.cpp b/src/hash.cpp
index 8c30a974b..3fb598d82 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,217 +1,219 @@
 // 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));
 }
 
 unsigned int MurmurHash3(unsigned int nHashSeed,
                          const std::vector<unsigned char> &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 int nblocks = vDataToHash.size() / 4;
 
         //----------
         // body
         const uint8_t *blocks = &vDataToHash[0] + nblocks * 4;
 
         for (int i = -nblocks; i; i++) {
             uint32_t k1 = ReadLE32(blocks + i * 4);
 
             k1 *= c1;
             k1 = ROTL32(k1, 15);
             k1 *= c2;
 
             h1 ^= k1;
             h1 = ROTL32(h1, 13);
             h1 = h1 * 5 + 0xe6546b64;
         }
 
         //----------
         // tail
         const uint8_t *tail = (const uint8_t *)(&vDataToHash[0] + nblocks * 4);
 
         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;
         }
     }
 
     //----------
     // finalization
     h1 ^= vDataToHash.size();
     h1 ^= h1 >> 16;
     h1 *= 0x85ebca6b;
     h1 ^= h1 >> 13;
     h1 *= 0xc2b2ae35;
     h1 ^= h1 >> 16;
 
     return h1;
 }
 
 void BIP32Hash(const ChainCode &chainCode, unsigned int nChild,
                unsigned char header, const unsigned char data[32],
                unsigned char output[64]) {
     unsigned char 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);
 }
 
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
 #define SIPROUND                                                               \
     do {                                                                       \
         v0 += v1;                                                              \
         v1 = ROTL(v1, 13);                                                     \
         v1 ^= v0;                                                              \
         v0 = ROTL(v0, 32);                                                     \
         v2 += v3;                                                              \
         v3 = ROTL(v3, 16);                                                     \
         v3 ^= v2;                                                              \
         v0 += v3;                                                              \
         v3 = ROTL(v3, 21);                                                     \
         v3 ^= v0;                                                              \
         v2 += v1;                                                              \
         v1 = ROTL(v1, 17);                                                     \
         v1 ^= v2;                                                              \
         v2 = ROTL(v2, 32);                                                     \
     } while (0)
 
 CSipHasher::CSipHasher(uint64_t k0, uint64_t k1) {
     v[0] = 0x736f6d6570736575ULL ^ k0;
     v[1] = 0x646f72616e646f6dULL ^ k1;
     v[2] = 0x6c7967656e657261ULL ^ k0;
     v[3] = 0x7465646279746573ULL ^ k1;
     count = 0;
     tmp = 0;
 }
 
 CSipHasher &CSipHasher::Write(uint64_t data) {
     uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
 
     assert(count % 8 == 0);
 
     v3 ^= data;
     SIPROUND;
     SIPROUND;
     v0 ^= data;
 
     v[0] = v0;
     v[1] = v1;
     v[2] = v2;
     v[3] = v3;
 
     count += 8;
     return *this;
 }
 
 CSipHasher &CSipHasher::Write(const unsigned char *data, size_t size) {
     uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
     uint64_t t = tmp;
     int c = count;
 
     while (size--) {
         t |= ((uint64_t)(*(data++))) << (8 * (c % 8));
         c++;
         if ((c & 7) == 0) {
             v3 ^= t;
             SIPROUND;
             SIPROUND;
             v0 ^= t;
             t = 0;
         }
     }
 
     v[0] = v0;
     v[1] = v1;
     v[2] = v2;
     v[3] = v3;
     count = c;
     tmp = t;
 
     return *this;
 }
 
 uint64_t CSipHasher::Finalize() const {
     uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
 
     uint64_t t = tmp | (((uint64_t)count) << 56);
 
     v3 ^= t;
     SIPROUND;
     SIPROUND;
     v0 ^= t;
     v2 ^= 0xFF;
     SIPROUND;
     SIPROUND;
     SIPROUND;
     SIPROUND;
     return v0 ^ v1 ^ v2 ^ v3;
 }
 
 uint64_t SipHashUint256(uint64_t k0, uint64_t k1, const uint256 &val) {
     /* Specialized implementation for efficiency */
     uint64_t d = val.GetUint64(0);
 
     uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
     uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
     uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
     uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
 
     SIPROUND;
     SIPROUND;
     v0 ^= d;
     d = val.GetUint64(1);
     v3 ^= d;
     SIPROUND;
     SIPROUND;
     v0 ^= d;
     d = val.GetUint64(2);
     v3 ^= d;
     SIPROUND;
     SIPROUND;
     v0 ^= d;
     d = val.GetUint64(3);
     v3 ^= d;
     SIPROUND;
     SIPROUND;
     v0 ^= d;
     v3 ^= ((uint64_t)4) << 59;
     SIPROUND;
     SIPROUND;
     v0 ^= ((uint64_t)4) << 59;
     v2 ^= 0xFF;
     SIPROUND;
     SIPROUND;
     SIPROUND;
     SIPROUND;
     return v0 ^ v1 ^ v2 ^ v3;
 }
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index f983b5ab3..3a34429da 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1,1280 +1,1282 @@
 // Copyright (c) 2011-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.
 
 #if defined(HAVE_CONFIG_H)
 #include "config/bitcoin-config.h"
 #endif
 
 #include "rpcconsole.h"
 #include "ui_debugwindow.h"
 
 #include "bantablemodel.h"
 #include "bantablemodel.h"
 #include "clientmodel.h"
 #include "guiutil.h"
 #include "platformstyle.h"
 
 #include "chainparams.h"
 #include "config.h"
 #include "netbase.h"
 #include "rpc/client.h"
 #include "rpc/server.h"
 #include "util.h"
 
 #include <openssl/crypto.h>
 
 #include <univalue.h>
 
 #ifdef ENABLE_WALLET
 #include <db_cxx.h>
 #endif
 
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStringList>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 
 #if QT_VERSION < 0x050000
 #include <QUrl>
 #endif
 
 // TODO: add a scrollback limit, as there is currently none
 // TODO: make it possible to filter out categories (esp debug messages when
 // implemented)
 // TODO: receive errors and debug messages through ClientModel
 
 const int CONSOLE_HISTORY = 50;
 const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
 const QSize FONT_RANGE(4, 40);
 const char fontSizeSettingsKey[] = "consoleFontSize";
 
 const struct {
     const char *url;
     const char *source;
 } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"},
                     {"cmd-reply", ":/icons/tx_output"},
                     {"cmd-error", ":/icons/tx_output"},
                     {"misc", ":/icons/tx_inout"},
                     {NULL, NULL}};
 
 namespace {
 
 // don't add private key handling cmd's to the history
 const QStringList historyFilter = QStringList() << "importprivkey"
                                                 << "importmulti"
                                                 << "signmessagewithprivkey"
                                                 << "signrawtransaction"
                                                 << "walletpassphrase"
                                                 << "walletpassphrasechange"
                                                 << "encryptwallet";
 }
 
 /* Object for executing console RPC commands in a separate thread.
 */
 class RPCExecutor : public QObject {
     Q_OBJECT
 
 public Q_SLOTS:
     void request(const QString &command);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
 };
 
 /** Class for handling RPC timers
  * (used for e.g. re-locking the wallet after a timeout)
  */
 class QtRPCTimerBase : public QObject, public RPCTimerBase {
     Q_OBJECT
 public:
     QtRPCTimerBase(boost::function<void(void)> &_func, int64_t millis)
         : func(_func) {
         timer.setSingleShot(true);
         connect(&timer, SIGNAL(timeout()), this, SLOT(timeout()));
         timer.start(millis);
     }
     ~QtRPCTimerBase() {}
 private Q_SLOTS:
     void timeout() { func(); }
 
 private:
     QTimer timer;
     boost::function<void(void)> func;
 };
 
 class QtRPCTimerInterface : public RPCTimerInterface {
 public:
     ~QtRPCTimerInterface() {}
     const char *Name() { return "Qt"; }
     RPCTimerBase *NewTimer(boost::function<void(void)> &func, int64_t millis) {
         return new QtRPCTimerBase(func, millis);
     }
 };
 
 #include "rpcconsole.moc"
 
 /**
  * Split shell command line into a list of arguments and optionally execute the
  * command(s).
  * Aims to emulate \c bash and friends.
  *
  * - Command nesting is possible with parenthesis; for example:
  * validateaddress(getnewaddress())
  * - Arguments are delimited with whitespace or comma
  * - Extra whitespace at the beginning and end and between arguments will be
  * ignored
  * - Text can be "double" or 'single' quoted
  * - The backslash \c \ is used as escape character
  *   - Outside quotes, any character can be escaped
  *   - Within double quotes, only escape \c " and backslashes before a \c " or
  * another backslash
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
  * @param[out]   pstrFilteredOut  Command line, filtered to remove any sensitive
  * data
  */
 
 bool RPCConsole::RPCParseCommandLine(std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut) {
     std::vector<std::vector<std::string>> stack;
     stack.push_back(std::vector<std::string>());
 
     enum CmdParseState {
         STATE_EATING_SPACES,
         STATE_EATING_SPACES_IN_ARG,
         STATE_EATING_SPACES_IN_BRACKETS,
         STATE_ARGUMENT,
         STATE_SINGLEQUOTED,
         STATE_DOUBLEQUOTED,
         STATE_ESCAPE_OUTER,
         STATE_ESCAPE_DOUBLEQUOTED,
         STATE_COMMAND_EXECUTED,
         STATE_COMMAND_EXECUTED_INNER
     } state = STATE_EATING_SPACES;
     std::string curarg;
     UniValue lastResult;
     unsigned nDepthInsideSensitive = 0;
     size_t filter_begin_pos = 0, chpos;
     std::vector<std::pair<size_t, size_t>> filter_ranges;
 
     auto add_to_current_stack = [&](const std::string &strArg) {
         if (stack.back().empty() && (!nDepthInsideSensitive) &&
             historyFilter.contains(QString::fromStdString(strArg),
                                    Qt::CaseInsensitive)) {
             nDepthInsideSensitive = 1;
             filter_begin_pos = chpos;
         }
         // Make sure stack is not empty before adding something
         if (stack.empty()) {
             stack.push_back(std::vector<std::string>());
         }
         stack.back().push_back(strArg);
     };
 
     auto close_out_params = [&]() {
         if (nDepthInsideSensitive) {
             if (!--nDepthInsideSensitive) {
                 assert(filter_begin_pos);
                 filter_ranges.push_back(
                     std::make_pair(filter_begin_pos, chpos));
                 filter_begin_pos = 0;
             }
         }
         stack.pop_back();
     };
 
     std::string strCommandTerminated = strCommand;
     if (strCommandTerminated.back() != '\n') strCommandTerminated += "\n";
     for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) {
         char ch = strCommandTerminated[chpos];
         switch (state) {
             case STATE_COMMAND_EXECUTED_INNER:
             case STATE_COMMAND_EXECUTED: {
                 bool breakParsing = true;
                 switch (ch) {
                     case '[':
                         curarg.clear();
                         state = STATE_COMMAND_EXECUTED_INNER;
                         break;
                     default:
                         if (state == STATE_COMMAND_EXECUTED_INNER) {
                             if (ch != ']') {
                                 // append char to the current argument (which is
                                 // also used for the query command)
                                 curarg += ch;
                                 break;
                             }
                             if (curarg.size() && fExecute) {
                                 // if we have a value query, query arrays with
                                 // index and objects with a string key
                                 UniValue subelement;
                                 if (lastResult.isArray()) {
                                     for (char argch : curarg)
                                         if (!std::isdigit(argch))
                                             throw std::runtime_error(
                                                 "Invalid result query");
                                     subelement =
                                         lastResult[atoi(curarg.c_str())];
                                 } else if (lastResult.isObject())
                                     subelement = find_value(lastResult, curarg);
                                 else {
                                     // no array or object: abort
                                     throw std::runtime_error(
                                         "Invalid result query");
                                 }
                                 lastResult = subelement;
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             break;
                         }
                         // don't break parsing when the char is required for the
                         // next argument
                         breakParsing = false;
 
                         // pop the stack and return the result to the current
                         // command arguments
                         close_out_params();
 
                         // don't stringify the json in case of a string to avoid
                         // doublequotes
                         if (lastResult.isStr())
                             curarg = lastResult.get_str();
                         else
                             curarg = lastResult.write(2);
 
                         // if we have a non empty result, use it as stack
                         // argument otherwise as general result
                         if (curarg.size()) {
                             if (stack.size())
                                 add_to_current_stack(curarg);
                             else
                                 strResult = curarg;
                         }
                         curarg.clear();
                         // assume eating space state
                         state = STATE_EATING_SPACES;
                 }
                 if (breakParsing) break;
+                // FALLTHROUGH
             }
             case STATE_ARGUMENT: // In or after argument
             case STATE_EATING_SPACES_IN_ARG:
             case STATE_EATING_SPACES_IN_BRACKETS:
             case STATE_EATING_SPACES: // Handle runs of whitespace
                 switch (ch) {
                     case '"':
                         state = STATE_DOUBLEQUOTED;
                         break;
                     case '\'':
                         state = STATE_SINGLEQUOTED;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_OUTER;
                         break;
                     case '(':
                     case ')':
                     case '\n':
                         if (state == STATE_EATING_SPACES_IN_ARG)
                             throw std::runtime_error("Invalid Syntax");
                         if (state == STATE_ARGUMENT) {
                             if (ch == '(' && stack.size() &&
                                 stack.back().size() > 0) {
                                 if (nDepthInsideSensitive) {
                                     ++nDepthInsideSensitive;
                                 }
                                 stack.push_back(std::vector<std::string>());
                             }
 
                             // don't allow commands after executed commands on
                             // baselevel
                             if (!stack.size())
                                 throw std::runtime_error("Invalid Syntax");
 
                             add_to_current_stack(curarg);
                             curarg.clear();
                             state = STATE_EATING_SPACES_IN_BRACKETS;
                         }
                         if ((ch == ')' || ch == '\n') && stack.size() > 0) {
                             if (fExecute) {
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
                                 JSONRPCRequest req;
                                 req.params = RPCConvertValues(
                                     stack.back()[0],
                                     std::vector<std::string>(
                                         stack.back().begin() + 1,
                                         stack.back().end()));
                                 req.strMethod = stack.back()[0];
                                 GlobalConfig config;
                                 lastResult = tableRPC.execute(config, req);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             curarg.clear();
                         }
                         break;
                     case ' ':
                     case ',':
                     case '\t':
                         if (state == STATE_EATING_SPACES_IN_ARG &&
                             curarg.empty() && ch == ',')
                             throw std::runtime_error("Invalid Syntax");
 
                         else if (state == STATE_ARGUMENT) // Space ends argument
                         {
                             add_to_current_stack(curarg);
                             curarg.clear();
                         }
                         if ((state == STATE_EATING_SPACES_IN_BRACKETS ||
                              state == STATE_ARGUMENT) &&
                             ch == ',') {
                             state = STATE_EATING_SPACES_IN_ARG;
                             break;
                         }
                         state = STATE_EATING_SPACES;
                         break;
                     default:
                         curarg += ch;
                         state = STATE_ARGUMENT;
                 }
                 break;
             case STATE_SINGLEQUOTED: // Single-quoted string
                 switch (ch) {
                     case '\'':
                         state = STATE_ARGUMENT;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_DOUBLEQUOTED: // Double-quoted string
                 switch (ch) {
                     case '"':
                         state = STATE_ARGUMENT;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_DOUBLEQUOTED;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_ESCAPE_OUTER: // '\' outside quotes
                 curarg += ch;
                 state = STATE_ARGUMENT;
                 break;
             case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
                 if (ch != '"' && ch != '\\')
                     curarg += '\\'; // keep '\' for everything but the quote and
                                     // '\' itself
                 curarg += ch;
                 state = STATE_DOUBLEQUOTED;
                 break;
         }
     }
     if (pstrFilteredOut) {
         if (STATE_COMMAND_EXECUTED == state) {
             assert(!stack.empty());
             close_out_params();
         }
         *pstrFilteredOut = strCommand;
         for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
             pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
         }
     }
     switch (state) // final state
     {
         case STATE_COMMAND_EXECUTED:
             if (lastResult.isStr())
                 strResult = lastResult.get_str();
             else
                 strResult = lastResult.write(2);
+        // FALLTHROUGH
         case STATE_ARGUMENT:
         case STATE_EATING_SPACES:
             return true;
         default: // ERROR to end in one of the other states
             return false;
     }
 }
 
 void RPCExecutor::request(const QString &command) {
     try {
         std::string result;
         std::string executableCommand = command.toStdString() + "\n";
         if (!RPCConsole::RPCExecuteCommandLine(result, executableCommand)) {
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString("Parse error: unbalanced ' or \""));
             return;
         }
         Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
     } catch (UniValue &objError) {
         try // Nice formatting for standard-format error
         {
             int code = find_value(objError, "code").get_int();
             std::string message = find_value(objError, "message").get_str();
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(message) + " (code " +
                              QString::number(code) + ")");
         } catch (const std::runtime_error &) {
             // raised when converting to invalid type, i.e. missing code or
             // message. Show raw JSON object.
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(objError.write()));
         }
     } catch (const std::exception &e) {
         Q_EMIT reply(RPCConsole::CMD_ERROR,
                      QString("Error: ") + QString::fromStdString(e.what()));
     }
 }
 
 RPCConsole::RPCConsole(const PlatformStyle *_platformStyle, QWidget *parent)
     : QWidget(parent), ui(new Ui::RPCConsole), clientModel(0), historyPtr(0),
       platformStyle(_platformStyle), peersTableContextMenu(0),
       banTableContextMenu(0), consoleFontSize(0) {
     ui->setupUi(this);
     GUIUtil::restoreWindowGeometry("nRPCConsoleWindow", this->size(), this);
 
     ui->openDebugLogfileButton->setToolTip(
         ui->openDebugLogfileButton->toolTip().arg(tr(PACKAGE_NAME)));
 
     if (platformStyle->getImagesOnButtons()) {
         ui->openDebugLogfileButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
     ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->fontBiggerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontbigger"));
     ui->fontSmallerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontsmaller"));
 
     // Install event filter for up and down arrow
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
     connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
     connect(ui->fontBiggerButton, SIGNAL(clicked()), this, SLOT(fontBigger()));
     connect(ui->fontSmallerButton, SIGNAL(clicked()), this,
             SLOT(fontSmaller()));
     connect(ui->btnClearTrafficGraph, SIGNAL(clicked()), ui->trafficGraph,
             SLOT(clear()));
 
 // set library version labels
 #ifdef ENABLE_WALLET
     ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
 #else
     ui->label_berkeleyDBVersion->hide();
     ui->berkeleyDBVersion->hide();
 #endif
     // Register RPC timer interface
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
     RPCSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 
     QSettings settings;
     consoleFontSize =
         settings.value(fontSizeSettingsKey, QFontInfo(QFont()).pointSize())
             .toInt();
     clear();
 }
 
 RPCConsole::~RPCConsole() {
     GUIUtil::saveWindowGeometry("nRPCConsoleWindow", this);
     RPCUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
 
 bool RPCConsole::eventFilter(QObject *obj, QEvent *event) {
     if (event->type() == QEvent::KeyPress) // Special key handling
     {
         QKeyEvent *keyevt = static_cast<QKeyEvent *>(event);
         int key = keyevt->key();
         Qt::KeyboardModifiers mod = keyevt->modifiers();
         switch (key) {
             case Qt::Key_Up:
                 if (obj == ui->lineEdit) {
                     browseHistory(-1);
                     return true;
                 }
                 break;
             case Qt::Key_Down:
                 if (obj == ui->lineEdit) {
                     browseHistory(1);
                     return true;
                 }
                 break;
             case Qt::Key_PageUp: /* pass paging keys to messages widget */
             case Qt::Key_PageDown:
                 if (obj == ui->lineEdit) {
                     QApplication::postEvent(ui->messagesWidget,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 // forward these events to lineEdit
                 if (obj == autoCompleter->popup()) {
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             default:
                 // Typing in messages widget brings focus to line edit, and
                 // redirects key there. Exclude most combinations and keys that
                 // emit no text, except paste shortcuts.
                 if (obj == ui->messagesWidget &&
                     ((!mod && !keyevt->text().isEmpty() &&
                       key != Qt::Key_Tab) ||
                      ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
                      ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
                     ui->lineEdit->setFocus();
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void RPCConsole::setClientModel(ClientModel *model) {
     clientModel = model;
     ui->trafficGraph->setClientModel(model);
     if (model && clientModel->getPeerTableModel() &&
         clientModel->getBanTableModel()) {
         // Keep up to date with client
         setNumConnections(model->getNumConnections());
         connect(model, SIGNAL(numConnectionsChanged(int)), this,
                 SLOT(setNumConnections(int)));
 
         setNumBlocks(model->getNumBlocks(), model->getLastBlockDate(),
                      model->getVerificationProgress(NULL), false);
         connect(model, SIGNAL(numBlocksChanged(int, QDateTime, double, bool)),
                 this, SLOT(setNumBlocks(int, QDateTime, double, bool)));
 
         updateNetworkState();
         connect(model, SIGNAL(networkActiveChanged(bool)), this,
                 SLOT(setNetworkActive(bool)));
 
         updateTrafficStats(model->getTotalBytesRecv(),
                            model->getTotalBytesSent());
         connect(model, SIGNAL(bytesChanged(quint64, quint64)), this,
                 SLOT(updateTrafficStats(quint64, quint64)));
 
         connect(model, SIGNAL(mempoolSizeChanged(long, size_t)), this,
                 SLOT(setMempoolSize(long, size_t)));
 
         // set up peer table
         ui->peerWidget->setModel(model->getPeerTableModel());
         ui->peerWidget->verticalHeader()->hide();
         ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
         ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->peerWidget->setColumnWidth(PeerTableModel::Address,
                                        ADDRESS_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Subversion,
                                        SUBVERSION_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
         ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create peer table context menu actions
         QAction *disconnectAction = new QAction(tr("&Disconnect"), this);
         QAction *banAction1h =
             new QAction(tr("Ban for") + " " + tr("1 &hour"), this);
         QAction *banAction24h =
             new QAction(tr("Ban for") + " " + tr("1 &day"), this);
         QAction *banAction7d =
             new QAction(tr("Ban for") + " " + tr("1 &week"), this);
         QAction *banAction365d =
             new QAction(tr("Ban for") + " " + tr("1 &year"), this);
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
         peersTableContextMenu->addAction(disconnectAction);
         peersTableContextMenu->addAction(banAction1h);
         peersTableContextMenu->addAction(banAction24h);
         peersTableContextMenu->addAction(banAction7d);
         peersTableContextMenu->addAction(banAction365d);
 
         // Add a signal mapping to allow dynamic context menu arguments. We need
         // to use int (instead of int64_t), because signal mapper only supports
         // int or objects, which is okay because max bantime (1 year) is <
         // int_max.
         QSignalMapper *signalMapper = new QSignalMapper(this);
         signalMapper->setMapping(banAction1h, 60 * 60);
         signalMapper->setMapping(banAction24h, 60 * 60 * 24);
         signalMapper->setMapping(banAction7d, 60 * 60 * 24 * 7);
         signalMapper->setMapping(banAction365d, 60 * 60 * 24 * 365);
         connect(banAction1h, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction24h, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction7d, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction365d, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(signalMapper, SIGNAL(mapped(int)), this,
                 SLOT(banSelectedNode(int)));
 
         // peer table context menu signals
         connect(ui->peerWidget,
                 SIGNAL(customContextMenuRequested(const QPoint &)), this,
                 SLOT(showPeersTableContextMenu(const QPoint &)));
         connect(disconnectAction, SIGNAL(triggered()), this,
                 SLOT(disconnectSelectedNode()));
 
         // peer table signal handling - update peer details when selecting new
         // node
         connect(ui->peerWidget->selectionModel(),
                 SIGNAL(selectionChanged(const QItemSelection &,
                                         const QItemSelection &)),
                 this, SLOT(peerSelected(const QItemSelection &,
                                         const QItemSelection &)));
         // peer table signal handling - update peer details when new nodes are
         // added to the model
         connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this,
                 SLOT(peerLayoutChanged()));
         // peer table signal handling - cache selected node ids
         connect(model->getPeerTableModel(), SIGNAL(layoutAboutToBeChanged()),
                 this, SLOT(peerLayoutAboutToChange()));
 
         // set up ban table
         ui->banlistWidget->setModel(model->getBanTableModel());
         ui->banlistWidget->verticalHeader()->hide();
         ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
         ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->banlistWidget->setColumnWidth(BanTableModel::Address,
                                           BANSUBNET_COLUMN_WIDTH);
         ui->banlistWidget->setColumnWidth(BanTableModel::Bantime,
                                           BANTIME_COLUMN_WIDTH);
         ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create ban table context menu action
         QAction *unbanAction = new QAction(tr("&Unban"), this);
 
         // create ban table context menu
         banTableContextMenu = new QMenu(this);
         banTableContextMenu->addAction(unbanAction);
 
         // ban table context menu signals
         connect(ui->banlistWidget,
                 SIGNAL(customContextMenuRequested(const QPoint &)), this,
                 SLOT(showBanTableContextMenu(const QPoint &)));
         connect(unbanAction, SIGNAL(triggered()), this,
                 SLOT(unbanSelectedNode()));
 
         // ban table signal handling - clear peer details when clicking a peer
         // in the ban table
         connect(ui->banlistWidget, SIGNAL(clicked(const QModelIndex &)), this,
                 SLOT(clearSelectedNode()));
         // ban table signal handling - ensure ban table is shown or hidden (if
         // empty)
         connect(model->getBanTableModel(), SIGNAL(layoutChanged()), this,
                 SLOT(showOrHideBanTableIfRequired()));
         showOrHideBanTableIfRequired();
 
         // Provide initial values
         ui->clientVersion->setText(model->formatFullVersion());
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->dataDir->setText(model->dataDir());
         ui->startupTime->setText(model->formatClientStartupTime());
         ui->networkName->setText(
             QString::fromStdString(Params().NetworkIDString()));
 
         // Setup autocomplete and attach it
         QStringList wordList;
         std::vector<std::string> commandList = tableRPC.listCommands();
         for (size_t i = 0; i < commandList.size(); ++i) {
             wordList << commandList[i].c_str();
         }
 
         autoCompleter = new QCompleter(wordList, this);
         ui->lineEdit->setCompleter(autoCompleter);
         autoCompleter->popup()->installEventFilter(this);
         // Start thread to execute RPC commands.
         startExecutor();
     }
     if (!model) {
         // Client model is being set to 0, this means shutdown() is about to be
         // called. Make sure we clean up the executor thread
         Q_EMIT stopExecutor();
         thread.wait();
     }
 }
 
 static QString categoryClass(int category) {
     switch (category) {
         case RPCConsole::CMD_REQUEST:
             return "cmd-request";
             break;
         case RPCConsole::CMD_REPLY:
             return "cmd-reply";
             break;
         case RPCConsole::CMD_ERROR:
             return "cmd-error";
             break;
         default:
             return "misc";
     }
 }
 
 void RPCConsole::fontBigger() {
     setFontSize(consoleFontSize + 1);
 }
 
 void RPCConsole::fontSmaller() {
     setFontSize(consoleFontSize - 1);
 }
 
 void RPCConsole::setFontSize(int newSize) {
     QSettings settings;
 
     // don't allow a insane font size
     if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) return;
 
     // temp. store the console content
     QString str = ui->messagesWidget->toHtml();
 
     // replace font tags size in current content
     str.replace(QString("font-size:%1pt").arg(consoleFontSize),
                 QString("font-size:%1pt").arg(newSize));
 
     // store the new font size
     consoleFontSize = newSize;
     settings.setValue(fontSizeSettingsKey, consoleFontSize);
 
     // clear console (reset icon sizes, default stylesheet) and re-add the
     // content
     float oldPosFactor = 1.0 /
                          ui->messagesWidget->verticalScrollBar()->maximum() *
                          ui->messagesWidget->verticalScrollBar()->value();
     clear(false);
     ui->messagesWidget->setHtml(str);
     ui->messagesWidget->verticalScrollBar()->setValue(
         oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
 }
 
 void RPCConsole::clear(bool clearHistory) {
     ui->messagesWidget->clear();
     if (clearHistory) {
         history.clear();
         historyPtr = 0;
     }
     ui->lineEdit->clear();
     ui->lineEdit->setFocus();
 
     // Add smoothly scaled icon images.
     // (when using width/height on an img, Qt uses nearest instead of linear
     // interpolation)
     for (int i = 0; ICON_MAPPING[i].url; ++i) {
         ui->messagesWidget->document()->addResource(
             QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url),
             platformStyle->SingleColorImage(ICON_MAPPING[i].source)
                 .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2),
                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
 
     // Set default style sheet
     QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
     ui->messagesWidget->document()->setDefaultStyleSheet(
         QString("table { }"
                 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
                 "td.message { font-family: %1; font-size: %2; "
                 "white-space:pre-wrap; } "
                 "td.cmd-request { color: #006060; } "
                 "td.cmd-error { color: red; } "
                 ".secwarning { color: red; }"
                 "b { color: #006060; } ")
             .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize)));
 
     message(CMD_REPLY,
             (tr("Welcome to the %1 RPC console.").arg(tr(PACKAGE_NAME)) +
              "<br>" + tr("Use up and down arrows to navigate history, and "
                          "<b>Ctrl-L</b> to clear screen.") +
              "<br>" +
              tr("Type <b>help</b> for an overview of available commands.")) +
                 "<br><span class=\"secwarning\">" +
                 tr("WARNING: Scammers have been active, telling users to type "
                    "commands here, stealing their wallet contents. Do not use "
                    "this console without fully understanding the ramification "
                    "of a command.") +
                 "</span>",
             true);
 }
 
 void RPCConsole::keyPressEvent(QKeyEvent *event) {
     if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) {
         close();
     }
 }
 
 void RPCConsole::message(int category, const QString &message, bool html) {
     QTime time = QTime::currentTime();
     QString timeString = time.toString();
     QString out;
     out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
     out += "<td class=\"icon\" width=\"32\"><img src=\"" +
            categoryClass(category) + "\"></td>";
     out += "<td class=\"message " + categoryClass(category) +
            "\" valign=\"middle\">";
     if (html)
         out += message;
     else
         out += GUIUtil::HtmlEscape(message, false);
     out += "</td></tr></table>";
     ui->messagesWidget->append(out);
 }
 
 void RPCConsole::updateNetworkState() {
     QString connections =
         QString::number(clientModel->getNumConnections()) + " (";
     connections +=
         tr("In:") + " " +
         QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
     connections +=
         tr("Out:") + " " +
         QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";
 
     if (!clientModel->getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
     ui->numberOfConnections->setText(connections);
 }
 
 void RPCConsole::setNumConnections(int count) {
     if (!clientModel) return;
 
     updateNetworkState();
 }
 
 void RPCConsole::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool headers) {
     if (!headers) {
         ui->numberOfBlocks->setText(QString::number(count));
         ui->lastBlockTime->setText(blockDate.toString());
     }
 }
 
 void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) {
     ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
 
     if (dynUsage < 1000000)
         ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) +
                                  " KB");
     else
         ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) +
                                  " MB");
 }
 
 void RPCConsole::on_lineEdit_returnPressed() {
     QString cmd = ui->lineEdit->text();
 
     if (!cmd.isEmpty()) {
         std::string strFilteredCmd;
         try {
             std::string dummy;
             if (!RPCParseCommandLine(dummy, cmd.toStdString(), false,
                                      &strFilteredCmd)) {
                 // Failed to parse command, so we cannot even filter it for the
                 // history
                 throw std::runtime_error("Invalid command line");
             }
         } catch (const std::exception &e) {
             QMessageBox::critical(this, "Error",
                                   QString("Error: ") +
                                       QString::fromStdString(e.what()));
             return;
         }
 
         ui->lineEdit->clear();
 
         cmdBeforeBrowsing = QString();
 
         message(CMD_REQUEST, cmd);
         Q_EMIT cmdRequest(cmd);
 
         cmd = QString::fromStdString(strFilteredCmd);
 
         // Remove command, if already in history
         history.removeOne(cmd);
         // Append command to history
         history.append(cmd);
         // Enforce maximum history size
         while (history.size() > CONSOLE_HISTORY)
             history.removeFirst();
         // Set pointer to end of history
         historyPtr = history.size();
 
         // Scroll console view to end
         scrollToEnd();
     }
 }
 
 void RPCConsole::browseHistory(int offset) {
     // store current text when start browsing through the history
     if (historyPtr == history.size()) {
         cmdBeforeBrowsing = ui->lineEdit->text();
     }
 
     historyPtr += offset;
     if (historyPtr < 0) historyPtr = 0;
     if (historyPtr > history.size()) historyPtr = history.size();
     QString cmd;
     if (historyPtr < history.size())
         cmd = history.at(historyPtr);
     else if (!cmdBeforeBrowsing.isNull()) {
         cmd = cmdBeforeBrowsing;
     }
     ui->lineEdit->setText(cmd);
 }
 
 void RPCConsole::startExecutor() {
     RPCExecutor *executor = new RPCExecutor();
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
     connect(executor, SIGNAL(reply(int, QString)), this,
             SLOT(message(int, QString)));
     // Requests from this object must go to executor
     connect(this, SIGNAL(cmdRequest(QString)), executor,
             SLOT(request(QString)));
 
     // On stopExecutor signal
     // - quit the Qt event loop in the execution thread
     connect(this, SIGNAL(stopExecutor()), &thread, SLOT(quit()));
     // - queue executor for deletion (in execution thread)
     connect(&thread, SIGNAL(finished()), executor, SLOT(deleteLater()),
             Qt::DirectConnection);
 
     // Default implementation of QThread::run() simply spins up an event loop in
     // the thread, which is what we want.
     thread.start();
 }
 
 void RPCConsole::on_tabWidget_currentChanged(int index) {
     if (ui->tabWidget->widget(index) == ui->tab_console)
         ui->lineEdit->setFocus();
     else if (ui->tabWidget->widget(index) != ui->tab_peers)
         clearSelectedNode();
 }
 
 void RPCConsole::on_openDebugLogfileButton_clicked() {
     GUIUtil::openDebugLogfile();
 }
 
 void RPCConsole::scrollToEnd() {
     QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
     scrollbar->setValue(scrollbar->maximum());
 }
 
 void RPCConsole::on_sldGraphRange_valueChanged(int value) {
     const int multiplier = 5; // each position on the slider represents 5 min
     int mins = value * multiplier;
     setTrafficGraphRange(mins);
 }
 
 QString RPCConsole::FormatBytes(quint64 bytes) {
     if (bytes < 1024) return QString(tr("%1 B")).arg(bytes);
     if (bytes < 1024 * 1024) return QString(tr("%1 KB")).arg(bytes / 1024);
     if (bytes < 1024 * 1024 * 1024)
         return QString(tr("%1 MB")).arg(bytes / 1024 / 1024);
 
     return QString(tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
 }
 
 void RPCConsole::setTrafficGraphRange(int mins) {
     ui->trafficGraph->setGraphRangeMins(mins);
     ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
 }
 
 void RPCConsole::updateTrafficStats(quint64 totalBytesIn,
                                     quint64 totalBytesOut) {
     ui->lblBytesIn->setText(FormatBytes(totalBytesIn));
     ui->lblBytesOut->setText(FormatBytes(totalBytesOut));
 }
 
 void RPCConsole::peerSelected(const QItemSelection &selected,
                               const QItemSelection &deselected) {
     Q_UNUSED(deselected);
 
     if (!clientModel || !clientModel->getPeerTableModel() ||
         selected.indexes().isEmpty())
         return;
 
     const CNodeCombinedStats *stats =
         clientModel->getPeerTableModel()->getNodeStats(
             selected.indexes().first().row());
     if (stats) updateNodeDetail(stats);
 }
 
 void RPCConsole::peerLayoutAboutToChange() {
     QModelIndexList selected =
         ui->peerWidget->selectionModel()->selectedIndexes();
     cachedNodeids.clear();
     for (int i = 0; i < selected.size(); i++) {
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(
                 selected.at(i).row());
         cachedNodeids.append(stats->nodeStats.nodeid);
     }
 }
 
 void RPCConsole::peerLayoutChanged() {
     if (!clientModel || !clientModel->getPeerTableModel()) return;
 
     const CNodeCombinedStats *stats = NULL;
     bool fUnselect = false;
     bool fReselect = false;
 
     if (cachedNodeids.empty()) // no node selected yet
         return;
 
     // find the currently selected row
     int selectedRow = -1;
     QModelIndexList selectedModelIndex =
         ui->peerWidget->selectionModel()->selectedIndexes();
     if (!selectedModelIndex.isEmpty()) {
         selectedRow = selectedModelIndex.first().row();
     }
 
     // check if our detail node has a row in the table (it may not necessarily
     // be at selectedRow since its position can change after a layout change)
     int detailNodeRow =
         clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first());
 
     if (detailNodeRow < 0) {
         // detail node disappeared from table (node disconnected)
         fUnselect = true;
     } else {
         if (detailNodeRow != selectedRow) {
             // detail node moved position
             fUnselect = true;
             fReselect = true;
         }
 
         // get fresh stats on the detail node.
         stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
     }
 
     if (fUnselect && selectedRow >= 0) {
         clearSelectedNode();
     }
 
     if (fReselect) {
         for (int i = 0; i < cachedNodeids.size(); i++) {
             ui->peerWidget->selectRow(
                 clientModel->getPeerTableModel()->getRowByNodeId(
                     cachedNodeids.at(i)));
         }
     }
 
     if (stats) updateNodeDetail(stats);
 }
 
 void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats) {
     // update the detail ui with latest node information
     QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) +
                             " ");
     peerAddrDetails +=
         tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
     if (!stats->nodeStats.addrLocal.empty())
         peerAddrDetails += "<br />" +
                            tr("via %1").arg(QString::fromStdString(
                                stats->nodeStats.addrLocal));
     ui->peerHeading->setText(peerAddrDetails);
     ui->peerServices->setText(
         GUIUtil::formatServicesStr(stats->nodeStats.nServices));
     ui->peerLastSend->setText(
         stats->nodeStats.nLastSend
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastSend)
             : tr("never"));
     ui->peerLastRecv->setText(
         stats->nodeStats.nLastRecv
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastRecv)
             : tr("never"));
     ui->peerBytesSent->setText(FormatBytes(stats->nodeStats.nSendBytes));
     ui->peerBytesRecv->setText(FormatBytes(stats->nodeStats.nRecvBytes));
     ui->peerConnTime->setText(GUIUtil::formatDurationStr(
         GetSystemTimeInSeconds() - stats->nodeStats.nTimeConnected));
     ui->peerPingTime->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
     ui->peerPingWait->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
     ui->peerMinPing->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dMinPing));
     ui->timeoffset->setText(
         GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     ui->peerVersion->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
     ui->peerSubversion->setText(
         QString::fromStdString(stats->nodeStats.cleanSubVer));
     ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound")
                                                          : tr("Outbound"));
     ui->peerHeight->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
     ui->peerWhitelisted->setText(stats->nodeStats.fWhitelisted ? tr("Yes")
                                                                : tr("No"));
 
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
         // Ban score is init to 0
         ui->peerBanScore->setText(
             QString("%1").arg(stats->nodeStateStats.nMisbehavior));
 
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1)
             ui->peerSyncHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nSyncHeight));
         else
             ui->peerSyncHeight->setText(tr("Unknown"));
 
         // Common height is init to -1
         if (stats->nodeStateStats.nCommonHeight > -1)
             ui->peerCommonHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nCommonHeight));
         else
             ui->peerCommonHeight->setText(tr("Unknown"));
     }
 
     ui->detailWidget->show();
 }
 
 void RPCConsole::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
 }
 
 void RPCConsole::showEvent(QShowEvent *event) {
     QWidget::showEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) return;
 
     // start PeerTableModel auto refresh
     clientModel->getPeerTableModel()->startAutoRefresh();
 }
 
 void RPCConsole::hideEvent(QHideEvent *event) {
     QWidget::hideEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) return;
 
     // stop PeerTableModel auto refresh
     clientModel->getPeerTableModel()->stopAutoRefresh();
 }
 
 void RPCConsole::showPeersTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->peerWidget->indexAt(point);
     if (index.isValid()) peersTableContextMenu->exec(QCursor::pos());
 }
 
 void RPCConsole::showBanTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->banlistWidget->indexAt(point);
     if (index.isValid()) banTableContextMenu->exec(QCursor::pos());
 }
 
 void RPCConsole::disconnectSelectedNode() {
     if (!g_connman) return;
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // Find the node, disconnect it and clear the selected node
         if (g_connman->DisconnectNode(id)) clearSelectedNode();
     }
 }
 
 void RPCConsole::banSelectedNode(int bantime) {
     if (!clientModel || !g_connman) return;
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
 
         // Get currently selected peer address
         int detailNodeRow =
             clientModel->getPeerTableModel()->getRowByNodeId(id);
         if (detailNodeRow < 0) return;
 
         // Find possible nodes, ban it and clear the selected node
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
             g_connman->Ban(stats->nodeStats.addr, BanReasonManuallyAdded,
                            bantime);
         }
     }
     clearSelectedNode();
     clientModel->getBanTableModel()->refresh();
 }
 
 void RPCConsole::unbanSelectedNode() {
     if (!clientModel) return;
 
     // Get selected ban addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected ban address
         QString strNode = nodes.at(i).data().toString();
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
         if (possibleSubnet.IsValid() && g_connman) {
             g_connman->Unban(possibleSubnet);
             clientModel->getBanTableModel()->refresh();
         }
     }
 }
 
 void RPCConsole::clearSelectedNode() {
     ui->peerWidget->selectionModel()->clearSelection();
     cachedNodeids.clear();
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 }
 
 void RPCConsole::showOrHideBanTableIfRequired() {
     if (!clientModel) return;
 
     bool visible = clientModel->getBanTableModel()->shouldShow();
     ui->banlistWidget->setVisible(visible);
     ui->banHeading->setVisible(visible);
 }
 
 void RPCConsole::setTabFocus(enum TabTypes tabType) {
     ui->tabWidget->setCurrentIndex(tabType);
 }
diff --git a/src/rest.cpp b/src/rest.cpp
index d60415139..2674bad49 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -1,666 +1,667 @@
 // 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 "chain.h"
 #include "chainparams.h"
 #include "httpserver.h"
 #include "primitives/block.h"
 #include "primitives/transaction.h"
 #include "rpc/blockchain.h"
 #include "rpc/server.h"
 #include "streams.h"
 #include "sync.h"
 #include "txmempool.h"
 #include "utilstrencodings.h"
 #include "validation.h"
 #include "version.h"
 
 #include <boost/algorithm/string.hpp>
 
 #include <univalue.h>
 
 // Allow a max of 15 outpoints to be queried at once.
 static const size_t MAX_GETUTXOS_OUTPOINTS = 15;
 
 enum RetFormat {
     RF_UNDEF,
     RF_BINARY,
     RF_HEX,
     RF_JSON,
 };
 
 static const struct {
     enum RetFormat rf;
     const char *name;
 } rf_names[] = {
     {RF_UNDEF, ""}, {RF_BINARY, "bin"}, {RF_HEX, "hex"}, {RF_JSON, "json"},
 };
 
 struct CCoin {
     // Don't call this nVersion, that name has a special meaning inside
     // IMPLEMENT_SERIALIZE
     uint32_t nTxVer;
     uint32_t nHeight;
     CTxOut out;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(nTxVer);
         READWRITE(nHeight);
         READWRITE(out);
     }
 };
 
 extern void TxToJSON(const CTransaction &tx, const uint256 hashBlock,
                      UniValue &entry);
 extern UniValue blockToJSON(const CBlock &block, const CBlockIndex *blockindex,
                             bool txDetails = false);
 extern UniValue mempoolInfoToJSON();
 extern UniValue mempoolToJSON(bool fVerbose = false);
 extern void ScriptPubKeyToJSON(const CScript &scriptPubKey, UniValue &out,
                                bool fIncludeHex);
 extern UniValue blockheaderToJSON(const CBlockIndex *blockindex);
 
 static bool RESTERR(HTTPRequest *req, enum HTTPStatusCode status,
                     std::string message) {
     req->WriteHeader("Content-Type", "text/plain");
     req->WriteReply(status, message + "\r\n");
     return false;
 }
 
 static enum RetFormat ParseDataFormat(std::string &param,
                                       const std::string &strReq) {
     const std::string::size_type pos = strReq.rfind('.');
     if (pos == std::string::npos) {
         param = strReq;
         return rf_names[0].rf;
     }
 
     param = strReq.substr(0, pos);
     const std::string suff(strReq, pos + 1);
 
     for (unsigned int i = 0; i < ARRAYLEN(rf_names); i++)
         if (suff == rf_names[i].name) return rf_names[i].rf;
 
     /* If no suffix is found, return original string.  */
     param = strReq;
     return rf_names[0].rf;
 }
 
 static std::string AvailableDataFormatsString() {
     std::string formats = "";
     for (unsigned int i = 0; i < ARRAYLEN(rf_names); i++)
         if (strlen(rf_names[i].name) > 0) {
             formats.append(".");
             formats.append(rf_names[i].name);
             formats.append(", ");
         }
 
     if (formats.length() > 0) return formats.substr(0, formats.length() - 2);
 
     return formats;
 }
 
 static bool ParseHashStr(const std::string &strReq, uint256 &v) {
     if (!IsHex(strReq) || (strReq.size() != 64)) return false;
 
     v.SetHex(strReq);
     return true;
 }
 
 static bool CheckWarmup(HTTPRequest *req) {
     std::string statusmessage;
     if (RPCIsInWarmup(&statusmessage))
         return RESTERR(req, HTTP_SERVICE_UNAVAILABLE,
                        "Service temporarily unavailable: " + statusmessage);
     return true;
 }
 
 static bool rest_headers(Config &config, HTTPRequest *req,
                          const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
     std::vector<std::string> path;
     boost::split(path, param, boost::is_any_of("/"));
 
     if (path.size() != 2)
         return RESTERR(req, HTTP_BAD_REQUEST, "No header count specified. Use "
                                               "/rest/headers/<count>/"
                                               "<hash>.<ext>.");
 
     long count = strtol(path[0].c_str(), NULL, 10);
     if (count < 1 || count > 2000)
         return RESTERR(req, HTTP_BAD_REQUEST,
                        "Header count out of range: " + path[0]);
 
     std::string hashStr = path[1];
     uint256 hash;
     if (!ParseHashStr(hashStr, hash))
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
 
     std::vector<const CBlockIndex *> headers;
     headers.reserve(count);
     {
         LOCK(cs_main);
         BlockMap::const_iterator it = mapBlockIndex.find(hash);
         const CBlockIndex *pindex =
             (it != mapBlockIndex.end()) ? it->second : NULL;
         while (pindex != NULL && chainActive.Contains(pindex)) {
             headers.push_back(pindex);
             if (headers.size() == (unsigned long)count) break;
             pindex = chainActive.Next(pindex);
         }
     }
 
     CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
     for (const CBlockIndex *pindex : headers) {
         ssHeader << pindex->GetBlockHeader();
     }
 
     switch (rf) {
         case RF_BINARY: {
             std::string binaryHeader = ssHeader.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryHeader);
             return true;
         }
 
         case RF_HEX: {
             std::string strHex =
                 HexStr(ssHeader.begin(), ssHeader.end()) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
         case RF_JSON: {
             UniValue jsonHeaders(UniValue::VARR);
             for (const CBlockIndex *pindex : headers) {
                 jsonHeaders.push_back(blockheaderToJSON(pindex));
             }
             std::string strJSON = jsonHeaders.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: .bin, .hex)");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_block(HTTPRequest *req, const std::string &strURIPart,
                        bool showTxDetails) {
     if (!CheckWarmup(req)) return false;
     std::string hashStr;
     const RetFormat rf = ParseDataFormat(hashStr, strURIPart);
 
     uint256 hash;
     if (!ParseHashStr(hashStr, hash))
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
 
     CBlock block;
     CBlockIndex *pblockindex = NULL;
     {
         LOCK(cs_main);
         if (mapBlockIndex.count(hash) == 0)
             return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
 
         pblockindex = mapBlockIndex[hash];
         if (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) &&
             pblockindex->nTx > 0)
             return RESTERR(req, HTTP_NOT_FOUND,
                            hashStr + " not available (pruned data)");
 
         if (!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus()))
             return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
     }
 
     CDataStream ssBlock(SER_NETWORK,
                         PROTOCOL_VERSION | RPCSerializationFlags());
     ssBlock << block;
 
     switch (rf) {
         case RF_BINARY: {
             std::string binaryBlock = ssBlock.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryBlock);
             return true;
         }
 
         case RF_HEX: {
             std::string strHex = HexStr(ssBlock.begin(), ssBlock.end()) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RF_JSON: {
             UniValue objBlock = blockToJSON(block, pblockindex, showTxDetails);
             std::string strJSON = objBlock.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
 
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_block_extended(Config &config, HTTPRequest *req,
                                 const std::string &strURIPart) {
     return rest_block(req, strURIPart, true);
 }
 
 static bool rest_block_notxdetails(Config &config, HTTPRequest *req,
                                    const std::string &strURIPart) {
     return rest_block(req, strURIPart, false);
 }
 
 static bool rest_chaininfo(Config &config, HTTPRequest *req,
                            const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RF_JSON: {
             JSONRPCRequest jsonRequest;
             jsonRequest.params = UniValue(UniValue::VARR);
             UniValue chainInfoObject = getblockchaininfo(config, jsonRequest);
             std::string strJSON = chainInfoObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_mempool_info(Config &config, HTTPRequest *req,
                               const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RF_JSON: {
             UniValue mempoolInfoObject = mempoolInfoToJSON();
 
             std::string strJSON = mempoolInfoObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_mempool_contents(Config &config, HTTPRequest *req,
                                   const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RF_JSON: {
             UniValue mempoolObject = mempoolToJSON(true);
 
             std::string strJSON = mempoolObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_tx(Config &config, HTTPRequest *req,
                     const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string hashStr;
     const RetFormat rf = ParseDataFormat(hashStr, strURIPart);
 
     uint256 hash;
     if (!ParseHashStr(hashStr, hash))
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
 
     CTransactionRef tx;
     uint256 hashBlock = uint256();
     if (!GetTransaction(config, hash, tx, hashBlock, true)) {
         return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION | RPCSerializationFlags());
     ssTx << tx;
 
     switch (rf) {
         case RF_BINARY: {
             std::string binaryTx = ssTx.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryTx);
             return true;
         }
 
         case RF_HEX: {
             std::string strHex = HexStr(ssTx.begin(), ssTx.end()) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RF_JSON: {
             UniValue objTx(UniValue::VOBJ);
             TxToJSON(*tx, hashBlock, objTx);
             std::string strJSON = objTx.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
 
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static bool rest_getutxos(Config &config, HTTPRequest *req,
                           const std::string &strURIPart) {
     if (!CheckWarmup(req)) return false;
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     std::vector<std::string> uriParts;
     if (param.length() > 1) {
         std::string strUriParams = param.substr(1);
         boost::split(uriParts, strUriParams, boost::is_any_of("/"));
     }
 
     // throw exception in case of a empty request
     std::string strRequestMutable = req->ReadBody();
     if (strRequestMutable.length() == 0 && uriParts.size() == 0)
         return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
 
     bool fInputParsed = false;
     bool fCheckMemPool = false;
     std::vector<COutPoint> vOutPoints;
 
     // parse/deserialize input
     // input-format = output-format, rest/getutxos/bin requires binary input,
     // gives binary output, ...
 
     if (uriParts.size() > 0) {
 
         // inputs is sent over URI scheme
         // (/rest/getutxos/checkmempool/txid1-n/txid2-n/...)
         if (uriParts.size() > 0 && uriParts[0] == "checkmempool")
             fCheckMemPool = true;
 
         for (size_t i = (fCheckMemPool) ? 1 : 0; i < uriParts.size(); i++) {
             uint256 txid;
             int32_t nOutput;
             std::string strTxid = uriParts[i].substr(0, uriParts[i].find("-"));
             std::string strOutput =
                 uriParts[i].substr(uriParts[i].find("-") + 1);
 
             if (!ParseInt32(strOutput, &nOutput) || !IsHex(strTxid))
                 return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
 
             txid.SetHex(strTxid);
             vOutPoints.push_back(COutPoint(txid, (uint32_t)nOutput));
         }
 
         if (vOutPoints.size() > 0) {
             fInputParsed = true;
         } else {
             return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
         }
     }
 
     switch (rf) {
         case RF_HEX: {
             // convert hex to bin, continue then with bin part
             std::vector<unsigned char> strRequestV =
                 ParseHex(strRequestMutable);
             strRequestMutable.assign(strRequestV.begin(), strRequestV.end());
+            // FALLTHROUGH
         }
 
         case RF_BINARY: {
             try {
                 // deserialize only if user sent a request
                 if (strRequestMutable.size() > 0) {
                     // don't allow sending input over URI and HTTP RAW DATA
                     if (fInputParsed) {
                         return RESTERR(req, HTTP_BAD_REQUEST,
                                        "Combination of URI scheme inputs and "
                                        "raw post data is not allowed");
                     }
 
                     CDataStream oss(SER_NETWORK, PROTOCOL_VERSION);
                     oss << strRequestMutable;
                     oss >> fCheckMemPool;
                     oss >> vOutPoints;
                 }
             } catch (const std::ios_base::failure &e) {
                 // abort in case of unreadable binary data
                 return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
             }
             break;
         }
 
         case RF_JSON: {
             if (!fInputParsed) {
                 return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
             }
             break;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 
     // limit max outpoints
     if (vOutPoints.size() > MAX_GETUTXOS_OUTPOINTS)
         return RESTERR(
             req, HTTP_BAD_REQUEST,
             strprintf("Error: max outpoints exceeded (max: %d, tried: %d)",
                       MAX_GETUTXOS_OUTPOINTS, vOutPoints.size()));
 
     // check spentness and form a bitmap (as well as a JSON capable
     // human-readable string representation)
     std::vector<unsigned char> bitmap;
     std::vector<CCoin> outs;
     std::string bitmapStringRepresentation;
     std::vector<bool> hits;
     bitmap.resize((vOutPoints.size() + 7) / 8);
     {
         LOCK2(cs_main, mempool.cs);
 
         CCoinsView viewDummy;
         CCoinsViewCache view(&viewDummy);
 
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, mempool);
 
         if (fCheckMemPool) {
             // switch cache backend to db+mempool in case user likes to query
             // mempool.
             view.SetBackend(viewMempool);
         }
 
         for (size_t i = 0; i < vOutPoints.size(); i++) {
             CCoins coins;
             uint256 hash = vOutPoints[i].hash;
             bool hit = false;
             if (view.GetCoins(hash, coins)) {
                 mempool.pruneSpent(hash, coins);
                 if (coins.IsAvailable(vOutPoints[i].n)) {
                     hit = true;
                     // Safe to index into vout here because IsAvailable checked
                     // if it's off the end of the array, or if n is valid but
                     // points to an already spent output (IsNull).
                     CCoin coin;
                     coin.nTxVer = coins.nVersion;
                     coin.nHeight = coins.nHeight;
                     coin.out = coins.vout.at(vOutPoints[i].n);
                     assert(!coin.out.IsNull());
                     outs.push_back(coin);
                 }
             }
 
             hits.push_back(hit);
             // form a binary string representation (human-readable for json
             // output)
             bitmapStringRepresentation.append(hit ? "1" : "0");
             bitmap[i / 8] |= ((uint8_t)hit) << (i % 8);
         }
     }
 
     switch (rf) {
         case RF_BINARY: {
             // serialize data
             // use exact same output as mentioned in Bip64
             CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
             ssGetUTXOResponse << chainActive.Height()
                               << chainActive.Tip()->GetBlockHash() << bitmap
                               << outs;
             std::string ssGetUTXOResponseString = ssGetUTXOResponse.str();
 
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, ssGetUTXOResponseString);
             return true;
         }
 
         case RF_HEX: {
             CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
             ssGetUTXOResponse << chainActive.Height()
                               << chainActive.Tip()->GetBlockHash() << bitmap
                               << outs;
             std::string strHex =
                 HexStr(ssGetUTXOResponse.begin(), ssGetUTXOResponse.end()) +
                 "\n";
 
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RF_JSON: {
             UniValue objGetUTXOResponse(UniValue::VOBJ);
 
             // pack in some essentials
             // use more or less the same output as mentioned in Bip64
             objGetUTXOResponse.push_back(
                 Pair("chainHeight", chainActive.Height()));
             objGetUTXOResponse.push_back(Pair(
                 "chaintipHash", chainActive.Tip()->GetBlockHash().GetHex()));
             objGetUTXOResponse.push_back(
                 Pair("bitmap", bitmapStringRepresentation));
 
             UniValue utxos(UniValue::VARR);
             for (const CCoin &coin : outs) {
                 UniValue utxo(UniValue::VOBJ);
                 utxo.push_back(Pair("txvers", (int32_t)coin.nTxVer));
                 utxo.push_back(Pair("height", (int32_t)coin.nHeight));
                 utxo.push_back(Pair("value", ValueFromAmount(coin.out.nValue)));
 
                 // include the script in a json output
                 UniValue o(UniValue::VOBJ);
                 ScriptPubKeyToJSON(coin.out.scriptPubKey, o, true);
                 utxo.push_back(Pair("scriptPubKey", o));
                 utxos.push_back(utxo);
             }
             objGetUTXOResponse.push_back(Pair("utxos", utxos));
 
             // return json string
             std::string strJSON = objGetUTXOResponse.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 
     // not reached
     // continue to process further HTTP reqs on this cxn
     return true;
 }
 
 static const struct {
     const char *prefix;
     bool (*handler)(Config &config, HTTPRequest *req,
                     const std::string &strReq);
 } uri_prefixes[] = {
     {"/rest/tx/", rest_tx},
     {"/rest/block/notxdetails/", rest_block_notxdetails},
     {"/rest/block/", rest_block_extended},
     {"/rest/chaininfo", rest_chaininfo},
     {"/rest/mempool/info", rest_mempool_info},
     {"/rest/mempool/contents", rest_mempool_contents},
     {"/rest/headers/", rest_headers},
     {"/rest/getutxos", rest_getutxos},
 };
 
 bool StartREST() {
     for (unsigned int i = 0; i < ARRAYLEN(uri_prefixes); i++)
         RegisterHTTPHandler(uri_prefixes[i].prefix, false,
                             uri_prefixes[i].handler);
     return true;
 }
 
 void InterruptREST() {}
 
 void StopREST() {
     for (unsigned int i = 0; i < ARRAYLEN(uri_prefixes); i++)
         UnregisterHTTPHandler(uri_prefixes[i].prefix, false);
 }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index b1892af33..80f68f84e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1,1041 +1,1041 @@
 // Copyright (c) 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 "amount.h"
 #include "base58.h"
 #include "chain.h"
 #include "chainparams.h"
 #include "config.h"
 #include "consensus/consensus.h"
 #include "consensus/params.h"
 #include "consensus/validation.h"
 #include "core_io.h"
 #include "init.h"
 #include "miner.h"
 #include "net.h"
 #include "pow.h"
 #include "rpc/server.h"
 #include "txmempool.h"
 #include "util.h"
 #include "utilstrencodings.h"
 #include "validation.h"
 #include "validationinterface.h"
 
 #include <cstdint>
 #include <memory>
 
 #include <boost/assign/list_of.hpp>
 #include <boost/shared_ptr.hpp>
 
 #include <univalue.h>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
  * or from the last difficulty change if 'lookup' is nonpositive. If 'height' is
  * nonnegative, compute the estimate at the time when a given block was found.
  */
 static UniValue GetNetworkHashPS(int lookup, int height) {
     CBlockIndex *pb = chainActive.Tip();
 
     if (height >= 0 && height < chainActive.Height()) pb = chainActive[height];
 
     if (pb == NULL || !pb->nHeight) return 0;
 
     // If lookup is -1, then use blocks since last difficulty change.
     if (lookup <= 0) {
         lookup = pb->nHeight %
                      Params().GetConsensus().DifficultyAdjustmentInterval() +
                  1;
     }
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight) lookup = pb->nHeight;
 
     CBlockIndex *pb0 = pb;
     int64_t minTime = pb0->GetBlockTime();
     int64_t maxTime = minTime;
     for (int i = 0; i < lookup; i++) {
         pb0 = pb0->pprev;
         int64_t time = pb0->GetBlockTime();
         minTime = std::min(time, minTime);
         maxTime = std::max(time, maxTime);
     }
 
     // In case there's a situation where minTime == maxTime, we don't want a
     // divide by zero exception.
     if (minTime == maxTime) return 0;
 
     arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
     int64_t timeDiff = maxTime - minTime;
 
     return workDiff.getdouble() / timeDiff;
 }
 
 static UniValue getnetworkhashps(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             "getnetworkhashps ( nblocks height )\n"
             "\nReturns the estimated network hashes per second based on the "
             "last n blocks.\n"
             "Pass in [blocks] to override # of blocks, -1 specifies since last "
             "difficulty change.\n"
             "Pass in [height] to estimate the network speed at the time when a "
             "certain block was found.\n"
             "\nArguments:\n"
             "1. nblocks     (numeric, optional, default=120) The number of "
             "blocks, or -1 for blocks since last difficulty change.\n"
             "2. height      (numeric, optional, default=-1) To estimate at the "
             "time of the given height.\n"
             "\nResult:\n"
             "x             (numeric) Hashes per second estimated\n"
             "\nExamples:\n" +
             HelpExampleCli("getnetworkhashps", "") +
             HelpExampleRpc("getnetworkhashps", ""));
     }
 
     LOCK(cs_main);
     return GetNetworkHashPS(
         request.params.size() > 0 ? request.params[0].get_int() : 120,
         request.params.size() > 1 ? request.params[1].get_int() : -1);
 }
 
 static UniValue generateBlocks(const Config &config,
                                boost::shared_ptr<CReserveScript> coinbaseScript,
                                int nGenerate, uint64_t nMaxTries,
                                bool keepScript) {
     static const int nInnerLoopCount = 0x10000;
     int nHeightStart = 0;
     int nHeightEnd = 0;
     int nHeight = 0;
 
     {
         // Don't keep cs_main locked.
         LOCK(cs_main);
         nHeightStart = chainActive.Height();
         nHeight = nHeightStart;
         nHeightEnd = nHeightStart + nGenerate;
     }
 
     unsigned int nExtraNonce = 0;
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd) {
         std::unique_ptr<CBlockTemplate> pblocktemplate(
             BlockAssembler(config, Params())
                 .CreateNewBlock(coinbaseScript->reserveScript));
         if (!pblocktemplate.get())
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         CBlock *pblock = &pblocktemplate->block;
         {
             LOCK(cs_main);
             IncrementExtraNonce(pblock, chainActive.Tip(), nExtraNonce);
         }
         while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount &&
                !CheckProofOfWork(pblock->GetHash(), pblock->nBits,
                                  Params().GetConsensus())) {
             ++pblock->nNonce;
             --nMaxTries;
         }
         if (nMaxTries == 0) {
             break;
         }
         if (pblock->nNonce == nInnerLoopCount) {
             continue;
         }
         std::shared_ptr<const CBlock> shared_pblock =
             std::make_shared<const CBlock>(*pblock);
         if (!ProcessNewBlock(config, shared_pblock, true, NULL))
             throw JSONRPCError(RPC_INTERNAL_ERROR,
                                "ProcessNewBlock, block not accepted");
         ++nHeight;
         blockHashes.push_back(pblock->GetHash().GetHex());
 
         // Mark script as important because it was used at least for one
         // coinbase output if the script came from the wallet.
         if (keepScript) {
             coinbaseScript->KeepScript();
         }
     }
     return blockHashes;
 }
 
 static UniValue generate(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             "generate nblocks ( maxtries )\n"
             "\nMine up to nblocks blocks immediately (before the RPC call "
             "returns)\n"
             "\nArguments:\n"
             "1. nblocks      (numeric, required) How many blocks are generated "
             "immediately.\n"
             "2. maxtries     (numeric, optional) How many iterations to try "
             "(default = 1000000).\n"
             "\nResult:\n"
             "[ blockhashes ]     (array) hashes of blocks generated\n"
             "\nExamples:\n"
             "\nGenerate 11 blocks\n" +
             HelpExampleCli("generate", "11"));
     }
 
     int nGenerate = request.params[0].get_int();
     uint64_t nMaxTries = 1000000;
     if (request.params.size() > 1) {
         nMaxTries = request.params[1].get_int();
     }
 
     boost::shared_ptr<CReserveScript> coinbaseScript;
     GetMainSignals().ScriptForMining(coinbaseScript);
 
     // If the keypool is exhausted, no script is returned at all. Catch this.
     if (!coinbaseScript) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
 
     // Throw an error if no script was provided.
     if (coinbaseScript->reserveScript.empty()) {
         throw JSONRPCError(
             RPC_INTERNAL_ERROR,
             "No coinbase script available (mining requires a wallet)");
     }
 
     return generateBlocks(config, coinbaseScript, nGenerate, nMaxTries, true);
 }
 
 static UniValue generatetoaddress(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             "generatetoaddress nblocks address (maxtries)\n"
             "\nMine blocks immediately to a specified address (before the RPC "
             "call returns)\n"
             "\nArguments:\n"
             "1. nblocks      (numeric, required) How many blocks are generated "
             "immediately.\n"
             "2. address      (string, required) The address to send the newly "
             "generated bitcoin to.\n"
             "3. maxtries     (numeric, optional) How many iterations to try "
             "(default = 1000000).\n"
             "\nResult:\n"
             "[ blockhashes ]     (array) hashes of blocks generated\n"
             "\nExamples:\n"
             "\nGenerate 11 blocks to myaddress\n" +
             HelpExampleCli("generatetoaddress", "11 \"myaddress\""));
     }
 
     int nGenerate = request.params[0].get_int();
     uint64_t nMaxTries = 1000000;
     if (request.params.size() > 2) {
         nMaxTries = request.params[2].get_int();
     }
 
     CBitcoinAddress address(request.params[1].get_str());
     if (!address.IsValid())
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Error: Invalid address");
 
     boost::shared_ptr<CReserveScript> coinbaseScript(new CReserveScript());
     coinbaseScript->reserveScript = GetScriptForDestination(address.Get());
 
     return generateBlocks(config, coinbaseScript, nGenerate, nMaxTries, false);
 }
 
 static UniValue getmininginfo(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             "getmininginfo\n"
             "\nReturns a json object containing mining-related information."
             "\nResult:\n"
             "{\n"
             "  \"blocks\": nnn,             (numeric) The current block\n"
             "  \"currentblocksize\": nnn,   (numeric) The last block size\n"
             "  \"currentblocktx\": nnn,     (numeric) The last block "
             "transaction\n"
             "  \"difficulty\": xxx.xxxxx    (numeric) The current difficulty\n"
             "  \"errors\": \"...\"            (string) Current errors\n"
             "  \"networkhashps\": nnn,      (numeric) The network hashes per "
             "second\n"
             "  \"pooledtx\": n              (numeric) The size of the mempool\n"
             "  \"chain\": \"xxxx\",           (string) current network name as "
             "defined in BIP70 (main, test, regtest)\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("getmininginfo", "") +
             HelpExampleRpc("getmininginfo", ""));
     }
 
     LOCK(cs_main);
 
     UniValue obj(UniValue::VOBJ);
     obj.push_back(Pair("blocks", (int)chainActive.Height()));
     obj.push_back(Pair("currentblocksize", (uint64_t)nLastBlockSize));
     obj.push_back(Pair("currentblocktx", (uint64_t)nLastBlockTx));
     obj.push_back(Pair("difficulty", (double)GetDifficulty()));
     obj.push_back(Pair("errors", GetWarnings("statusbar")));
     obj.push_back(Pair("networkhashps", getnetworkhashps(config, request)));
     obj.push_back(Pair("pooledtx", (uint64_t)mempool.size()));
     obj.push_back(Pair("chain", Params().NetworkIDString()));
     return obj;
 }
 
 // NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP
 // 22) in using satoshi amounts
 static UniValue prioritisetransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 3) {
         throw std::runtime_error(
             "prioritisetransaction <txid> <priority delta> <fee delta>\n"
             "Accepts the transaction into mined blocks at a higher (or lower) "
             "priority\n"
             "\nArguments:\n"
             "1. \"txid\"       (string, required) The transaction id.\n"
             "2. priority_delta (numeric, required) The priority to add or "
             "subtract.\n"
             "                  The transaction selection algorithm considers "
             "the tx as it would have a higher priority.\n"
             "                  (priority of a transaction is calculated: "
             "coinage * value_in_satoshis / txsize) \n"
             "3. fee_delta      (numeric, required) The fee value (in satoshis) "
             "to add (or subtract, if negative).\n"
             "                  The fee is not actually paid, only the "
             "algorithm for selecting transactions into a block\n"
             "                  considers the transaction as it would have paid "
             "a higher (or lower) fee.\n"
             "\nResult:\n"
             "true              (boolean) Returns true\n"
             "\nExamples:\n" +
             HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000") +
             HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000"));
     }
 
     LOCK(cs_main);
 
     uint256 hash = ParseHashStr(request.params[0].get_str(), "txid");
     CAmount nAmount = request.params[2].get_int64();
 
     mempool.PrioritiseTransaction(hash, request.params[0].get_str(),
                                   request.params[1].get_real(), nAmount);
     return true;
 }
 
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be
 // handled by caller
 static UniValue BIP22ValidationResult(const Config &config,
                                       const CValidationState &state) {
     if (state.IsValid()) return NullUniValue;
 
     std::string strRejectReason = state.GetRejectReason();
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, strRejectReason);
     }
 
     if (state.IsInvalid()) {
         if (strRejectReason.empty()) return "rejected";
         return strRejectReason;
     }
 
     // Should be impossible.
     return "valid?";
 }
 
 std::string gbt_vb_name(const Consensus::DeploymentPos pos) {
     const struct BIP9DeploymentInfo &vbinfo = VersionBitsDeploymentInfo[pos];
     std::string s = vbinfo.name;
     if (!vbinfo.gbt_force) {
         s.insert(s.begin(), '!');
     }
     return s;
 }
 
 static UniValue getblocktemplate(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(
             "getblocktemplate ( TemplateRequest )\n"
             "\nIf the request parameters include a 'mode' key, that is used to "
             "explicitly select between the default 'template' request or a "
             "'proposal'.\n"
             "It returns data needed to construct a block to work on.\n"
             "For full specification, see BIPs 22, 23, 9, and 145:\n"
             "    "
             "https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
             "    "
             "https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
             "    "
             "https://github.com/bitcoin/bips/blob/master/"
             "bip-0009.mediawiki#getblocktemplate_changes\n"
             "    "
             "https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n"
 
             "\nArguments:\n"
             "1. template_request         (json object, optional) A json object "
             "in the following spec\n"
             "     {\n"
             "       \"mode\":\"template\"    (string, optional) This must be "
             "set to \"template\", \"proposal\" (see BIP 23), or omitted\n"
             "       \"capabilities\":[     (array, optional) A list of "
             "strings\n"
             "           \"support\"          (string) client side supported "
             "feature, 'longpoll', 'coinbasetxn', 'coinbasevalue', 'proposal', "
             "'serverlist', 'workid'\n"
             "           ,...\n"
             "       ],\n"
             "       \"rules\":[            (array, optional) A list of "
             "strings\n"
             "           \"support\"          (string) client side supported "
             "softfork deployment\n"
             "           ,...\n"
             "       ]\n"
             "     }\n"
             "\n"
 
             "\nResult:\n"
             "{\n"
             "  \"version\" : n,                    (numeric) The preferred "
             "block version\n"
             "  \"rules\" : [ \"rulename\", ... ],    (array of strings) "
             "specific block rules that are to be enforced\n"
             "  \"vbavailable\" : {                 (json object) set of "
             "pending, supported versionbit (BIP 9) softfork deployments\n"
             "      \"rulename\" : bitnumber          (numeric) identifies the "
             "bit number as indicating acceptance and readiness for the named "
             "softfork rule\n"
             "      ,...\n"
             "  },\n"
             "  \"vbrequired\" : n,                 (numeric) bit mask of "
             "versionbits the server requires set in submissions\n"
             "  \"previousblockhash\" : \"xxxx\",     (string) The hash of "
             "current highest block\n"
             "  \"transactions\" : [                (array) contents of "
             "non-coinbase transactions that should be included in the next "
             "block\n"
             "      {\n"
             "         \"data\" : \"xxxx\",             (string) transaction "
             "data encoded in hexadecimal (byte-for-byte)\n"
             "         \"txid\" : \"xxxx\",             (string) transaction id "
             "encoded in little-endian hexadecimal\n"
             "         \"hash\" : \"xxxx\",             (string) hash encoded "
             "in little-endian hexadecimal (including witness data)\n"
             "         \"depends\" : [                (array) array of numbers "
             "\n"
             "             n                          (numeric) transactions "
             "before this one (by 1-based index in 'transactions' list) that "
             "must be present in the final block if this one is\n"
             "             ,...\n"
             "         ],\n"
             "         \"fee\": n,                    (numeric) difference in "
             "value between transaction inputs and outputs (in Satoshis); for "
             "coinbase transactions, this is a negative Number of the total "
             "collected block fees (ie, not including the block subsidy); if "
             "key is not present, fee is unknown and clients MUST NOT assume "
             "there isn't one\n"
             "         \"sigops\" : n,                (numeric) total SigOps "
             "cost, as counted for purposes of block limits; if key is not "
             "present, sigop cost is unknown and clients MUST NOT assume it is "
             "zero\n"
             "         \"required\" : true|false      (boolean) if provided and "
             "true, this transaction must be in the final block\n"
             "      }\n"
             "      ,...\n"
             "  ],\n"
             "  \"coinbaseaux\" : {                 (json object) data that "
             "should be included in the coinbase's scriptSig content\n"
             "      \"flags\" : \"xx\"                  (string) key name is to "
             "be ignored, and value included in scriptSig\n"
             "  },\n"
             "  \"coinbasevalue\" : n,              (numeric) maximum allowable "
             "input to coinbase transaction, including the generation award and "
             "transaction fees (in Satoshis)\n"
             "  \"coinbasetxn\" : { ... },          (json object) information "
             "for coinbase transaction\n"
             "  \"target\" : \"xxxx\",                (string) The hash target\n"
             "  \"mintime\" : xxx,                  (numeric) The minimum "
             "timestamp appropriate for next block time in seconds since epoch "
             "(Jan 1 1970 GMT)\n"
             "  \"mutable\" : [                     (array of string) list of "
             "ways the block template may be changed \n"
             "     \"value\"                          (string) A way the block "
             "template may be changed, e.g. 'time', 'transactions', "
             "'prevblock'\n"
             "     ,...\n"
             "  ],\n"
             "  \"noncerange\" : \"00000000ffffffff\",(string) A range of valid "
             "nonces\n"
             "  \"sigoplimit\" : n,                 (numeric) limit of sigops "
             "in blocks\n"
             "  \"sizelimit\" : n,                  (numeric) limit of block "
             "size\n"
             "  \"curtime\" : ttt,                  (numeric) current timestamp "
             "in seconds since epoch (Jan 1 1970 GMT)\n"
             "  \"bits\" : \"xxxxxxxx\",              (string) compressed "
             "target of next block\n"
             "  \"height\" : n                      (numeric) The height of the "
             "next block\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("getblocktemplate", "") +
             HelpExampleRpc("getblocktemplate", ""));
     }
 
     LOCK(cs_main);
 
     std::string strMode = "template";
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
     int64_t nMaxVersionPreVB = -1;
     if (request.params.size() > 0) {
         const UniValue &oparam = request.params[0].get_obj();
         const UniValue &modeval = find_value(oparam, "mode");
         if (modeval.isStr())
             strMode = modeval.get_str();
         else if (modeval.isNull()) {
             /* Do nothing */
         } else
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
         lpval = find_value(oparam, "longpollid");
 
         if (strMode == "proposal") {
             const UniValue &dataval = find_value(oparam, "data");
             if (!dataval.isStr())
                 throw JSONRPCError(RPC_TYPE_ERROR,
                                    "Missing data String key for proposal");
 
             CBlock block;
             if (!DecodeHexBlk(block, dataval.get_str()))
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block decode failed");
 
             uint256 hash = block.GetHash();
             BlockMap::iterator mi = mapBlockIndex.find(hash);
             if (mi != mapBlockIndex.end()) {
                 CBlockIndex *pindex = mi->second;
                 if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) return "duplicate";
                 if (pindex->nStatus & BLOCK_FAILED_MASK)
                     return "duplicate-invalid";
                 return "duplicate-inconclusive";
             }
 
             CBlockIndex *const pindexPrev = chainActive.Tip();
             // TestBlockValidity only supports blocks built on the current Tip
             if (block.hashPrevBlock != pindexPrev->GetBlockHash())
                 return "inconclusive-not-best-prevblk";
             CValidationState state;
             TestBlockValidity(config, state, Params(), block, pindexPrev, false,
                               true);
             return BIP22ValidationResult(config, state);
         }
 
         const UniValue &aClientRules = find_value(oparam, "rules");
         if (aClientRules.isArray()) {
             for (unsigned int i = 0; i < aClientRules.size(); ++i) {
                 const UniValue &v = aClientRules[i];
                 setClientRules.insert(v.get_str());
             }
         } else {
             // NOTE: It is important that this NOT be read if versionbits is
             // supported
             const UniValue &uvMaxVersion = find_value(oparam, "maxversion");
             if (uvMaxVersion.isNum()) {
                 nMaxVersionPreVB = uvMaxVersion.get_int64();
             }
         }
     }
 
     if (strMode != "template")
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
 
     if (!g_connman)
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
 
     if (g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
         throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
                            "Bitcoin is not connected!");
 
     if (IsInitialBlockDownload())
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
                            "Bitcoin is downloading blocks...");
 
     static unsigned int nTransactionsUpdatedLast;
 
     if (!lpval.isNull()) {
         // Wait to respond until either the best block changes, OR a minute has
         // passed and there are more transactions
         uint256 hashWatchedChain;
         boost::system_time checktxtime;
         unsigned int nTransactionsUpdatedLastLP;
 
         if (lpval.isStr()) {
             // Format: <hashBestChain><nTransactionsUpdatedLast>
             std::string lpstr = lpval.get_str();
 
             hashWatchedChain.SetHex(lpstr.substr(0, 64));
             nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
         } else {
             // NOTE: Spec does not specify behaviour for non-string longpollid,
             // but this makes testing easier
             hashWatchedChain = chainActive.Tip()->GetBlockHash();
             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
         }
 
         // Release the wallet and main lock while waiting
         LEAVE_CRITICAL_SECTION(cs_main);
         {
             checktxtime =
                 boost::get_system_time() + boost::posix_time::minutes(1);
 
             boost::unique_lock<boost::mutex> lock(csBestBlock);
             while (chainActive.Tip()->GetBlockHash() == hashWatchedChain &&
                    IsRPCRunning()) {
                 if (!cvBlockChange.timed_wait(lock, checktxtime)) {
                     // Timeout: Check transactions for update
                     if (mempool.GetTransactionsUpdated() !=
                         nTransactionsUpdatedLastLP)
                         break;
                     checktxtime += boost::posix_time::seconds(10);
                 }
             }
         }
         ENTER_CRITICAL_SECTION(cs_main);
 
         if (!IsRPCRunning())
             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
         // TODO: Maybe recheck connections/IBD and (if something wrong) send an
         // expires-immediately template to stop miners?
     }
 
     // Update block
     static CBlockIndex *pindexPrev;
     static int64_t nStart;
     static std::unique_ptr<CBlockTemplate> pblocktemplate;
     if (pindexPrev != chainActive.Tip() ||
         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast &&
          GetTime() - nStart > 5)) {
         // Clear pindexPrev so future calls make a new block, despite any
         // failures from here on
         pindexPrev = nullptr;
 
         // Store the pindexBest used before CreateNewBlock, to avoid races
         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
         CBlockIndex *pindexPrevNew = chainActive.Tip();
         nStart = GetTime();
 
         // Create new block
         CScript scriptDummy = CScript() << OP_TRUE;
         pblocktemplate =
             BlockAssembler(config, Params()).CreateNewBlock(scriptDummy);
         if (!pblocktemplate)
             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
 
         // Need to update only after we know CreateNewBlock succeeded
         pindexPrev = pindexPrevNew;
     }
     CBlock *pblock = &pblocktemplate->block; // pointer for convenience
     const Consensus::Params &consensusParams = Params().GetConsensus();
 
     // Update nTime
     UpdateTime(pblock, consensusParams, pindexPrev);
     pblock->nNonce = 0;
 
     UniValue aCaps(UniValue::VARR);
     aCaps.push_back("proposal");
 
     UniValue transactions(UniValue::VARR);
     std::map<uint256, int64_t> setTxIndex;
     int i = 0;
     for (const auto &it : pblock->vtx) {
         const CTransaction &tx = *it;
         uint256 txId = tx.GetId();
         setTxIndex[txId] = i++;
 
         if (tx.IsCoinBase()) continue;
 
         UniValue entry(UniValue::VOBJ);
 
         entry.push_back(Pair("data", EncodeHexTx(tx)));
         entry.push_back(Pair("txid", txId.GetHex()));
         entry.push_back(Pair("hash", tx.GetHash().GetHex()));
 
         UniValue deps(UniValue::VARR);
         for (const CTxIn &in : tx.vin) {
             if (setTxIndex.count(in.prevout.hash))
                 deps.push_back(setTxIndex[in.prevout.hash]);
         }
         entry.push_back(Pair("depends", deps));
 
         int index_in_template = i - 1;
         entry.push_back(
             Pair("fee", pblocktemplate->vTxFees[index_in_template]));
         int64_t nTxSigOps = pblocktemplate->vTxSigOpsCount[index_in_template];
         entry.push_back(Pair("sigops", nTxSigOps));
 
         transactions.push_back(entry);
     }
 
     UniValue aux(UniValue::VOBJ);
     aux.push_back(
         Pair("flags", HexStr(COINBASE_FLAGS.begin(), COINBASE_FLAGS.end())));
 
     arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
 
     UniValue aMutable(UniValue::VARR);
     aMutable.push_back("time");
     aMutable.push_back("transactions");
     aMutable.push_back("prevblock");
 
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("capabilities", aCaps));
 
     UniValue aRules(UniValue::VARR);
     UniValue vbavailable(UniValue::VOBJ);
     for (int j = 0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
         Consensus::DeploymentPos pos = Consensus::DeploymentPos(j);
         ThresholdState state = VersionBitsState(pindexPrev, consensusParams,
                                                 pos, versionbitscache);
         switch (state) {
             case THRESHOLD_DEFINED:
             case THRESHOLD_FAILED:
                 // Not exposed to GBT at all
                 break;
             case THRESHOLD_LOCKED_IN:
                 // Ensure bit is set in block version
                 pblock->nVersion |= VersionBitsMask(consensusParams, pos);
-            // FALL THROUGH to get vbavailable set...
+            // FALLTHROUGH to get vbavailable set...
             case THRESHOLD_STARTED: {
                 const struct BIP9DeploymentInfo &vbinfo =
                     VersionBitsDeploymentInfo[pos];
                 vbavailable.push_back(Pair(
                     gbt_vb_name(pos), consensusParams.vDeployments[pos].bit));
                 if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
                     if (!vbinfo.gbt_force) {
                         // If the client doesn't support this, don't indicate it
                         // in the [default] version
                         pblock->nVersion &=
                             ~VersionBitsMask(consensusParams, pos);
                     }
                 }
                 break;
             }
             case THRESHOLD_ACTIVE: {
                 // Add to rules only
                 const struct BIP9DeploymentInfo &vbinfo =
                     VersionBitsDeploymentInfo[pos];
                 aRules.push_back(gbt_vb_name(pos));
                 if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
                     // Not supported by the client; make sure it's safe to
                     // proceed
                     if (!vbinfo.gbt_force) {
                         // If we do anything other than throw an exception here,
                         // be sure version/force isn't sent to old clients
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             strprintf("Support for '%s' rule requires explicit "
                                       "client support",
                                       vbinfo.name));
                     }
                 }
                 break;
             }
         }
     }
     result.push_back(Pair("version", pblock->nVersion));
     result.push_back(Pair("rules", aRules));
     result.push_back(Pair("vbavailable", vbavailable));
     result.push_back(Pair("vbrequired", int(0)));
 
     if (nMaxVersionPreVB >= 2) {
         // If VB is supported by the client, nMaxVersionPreVB is -1, so we won't
         // get here. Because BIP 34 changed how the generation transaction is
         // serialized, we can only use version/force back to v2 blocks. This is
         // safe to do [otherwise-]unconditionally only because we are throwing
         // an exception above if a non-force deployment gets activated. Note
         // that this can probably also be removed entirely after the first BIP9
         // non-force deployment (ie, probably segwit) gets activated.
         aMutable.push_back("version/force");
     }
 
     result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));
     result.push_back(Pair("transactions", transactions));
     result.push_back(Pair("coinbaseaux", aux));
     result.push_back(
         Pair("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue));
     result.push_back(
         Pair("longpollid", chainActive.Tip()->GetBlockHash().GetHex() +
                                i64tostr(nTransactionsUpdatedLast)));
     result.push_back(Pair("target", hashTarget.GetHex()));
     result.push_back(
         Pair("mintime", (int64_t)pindexPrev->GetMedianTimePast() + 1));
     result.push_back(Pair("mutable", aMutable));
     result.push_back(Pair("noncerange", "00000000ffffffff"));
     // FIXME: Allow for mining block greater than 1M.
     result.push_back(
         Pair("sigoplimit", GetMaxBlockSigOpsCount(DEFAULT_MAX_BLOCK_SIZE)));
     result.push_back(Pair("sizelimit", DEFAULT_MAX_BLOCK_SIZE));
     result.push_back(Pair("curtime", pblock->GetBlockTime()));
     result.push_back(Pair("bits", strprintf("%08x", pblock->nBits)));
     result.push_back(Pair("height", (int64_t)(pindexPrev->nHeight + 1)));
 
     return result;
 }
 
 class submitblock_StateCatcher : public CValidationInterface {
 public:
     uint256 hash;
     bool found;
     CValidationState state;
 
     submitblock_StateCatcher(const uint256 &hashIn)
         : hash(hashIn), found(false), state() {}
 
 protected:
     virtual void BlockChecked(const CBlock &block,
                               const CValidationState &stateIn) {
         if (block.GetHash() != hash) return;
         found = true;
         state = stateIn;
     }
 };
 
 static UniValue submitblock(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             "submitblock \"hexdata\" ( \"jsonparametersobject\" )\n"
             "\nAttempts to submit new block to network.\n"
             "The 'jsonparametersobject' parameter is currently ignored.\n"
             "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n"
 
             "\nArguments\n"
             "1. \"hexdata\"        (string, required) the hex-encoded block "
             "data to submit\n"
             "2. \"parameters\"     (string, optional) object of optional "
             "parameters\n"
             "    {\n"
             "      \"workid\" : \"id\"    (string, optional) if the server "
             "provided a workid, it MUST be included with submissions\n"
             "    }\n"
             "\nResult:\n"
             "\nExamples:\n" +
             HelpExampleCli("submitblock", "\"mydata\"") +
             HelpExampleRpc("submitblock", "\"mydata\""));
     }
 
     std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
     CBlock &block = *blockptr;
     if (!DecodeHexBlk(block, request.params[0].get_str()))
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
 
     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            "Block does not start with a coinbase");
     }
 
     uint256 hash = block.GetHash();
     bool fBlockPresent = false;
     {
         LOCK(cs_main);
         BlockMap::iterator mi = mapBlockIndex.find(hash);
         if (mi != mapBlockIndex.end()) {
             CBlockIndex *pindex = mi->second;
             if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) return "duplicate";
             if (pindex->nStatus & BLOCK_FAILED_MASK) return "duplicate-invalid";
             // Otherwise, we might only have the header - process the block
             // before returning
             fBlockPresent = true;
         }
     }
 
     submitblock_StateCatcher sc(block.GetHash());
     RegisterValidationInterface(&sc);
     bool fAccepted = ProcessNewBlock(config, blockptr, true, NULL);
     UnregisterValidationInterface(&sc);
     if (fBlockPresent) {
         if (fAccepted && !sc.found) return "duplicate-inconclusive";
         return "duplicate";
     }
     if (!sc.found) return "inconclusive";
     return BIP22ValidationResult(config, sc.state);
 }
 
 static UniValue estimatefee(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "estimatefee nblocks\n"
             "\nEstimates the approximate fee per kilobyte needed for a "
             "transaction to begin\n"
             "confirmation within nblocks blocks.\n"
             "\nArguments:\n"
             "1. nblocks     (numeric, required)\n"
             "\nResult:\n"
             "n              (numeric) estimated fee-per-kilobyte\n"
             "\n"
             "A negative value is returned if not enough transactions and "
             "blocks\n"
             "have been observed to make an estimate.\n"
             "-1 is always returned for nblocks == 1 as it is impossible to "
             "calculate\n"
             "a fee that is high enough to get reliably included in the next "
             "block.\n"
             "\nExample:\n" +
             HelpExampleCli("estimatefee", "6"));
     }
 
     RPCTypeCheck(request.params, boost::assign::list_of(UniValue::VNUM));
 
     int nBlocks = request.params[0].get_int();
     if (nBlocks < 1) nBlocks = 1;
 
     CFeeRate feeRate = mempool.estimateFee(nBlocks);
     if (feeRate == CFeeRate(0)) return -1.0;
 
     return ValueFromAmount(feeRate.GetFeePerK());
 }
 
 static UniValue estimatepriority(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "estimatepriority nblocks\n"
             "\nDEPRECATED. Estimates the approximate priority "
             "a zero-fee transaction needs to begin\n"
             "confirmation within nblocks blocks.\n"
             "\nArguments:\n"
             "1. nblocks     (numeric, required)\n"
             "\nResult:\n"
             "n              (numeric) estimated priority\n"
             "\n"
             "A negative value is returned if not enough "
             "transactions and blocks\n"
             "have been observed to make an estimate.\n"
             "\nExample:\n" +
             HelpExampleCli("estimatepriority", "6"));
     }
 
     RPCTypeCheck(request.params, boost::assign::list_of(UniValue::VNUM));
 
     int nBlocks = request.params[0].get_int();
     if (nBlocks < 1) nBlocks = 1;
 
     return mempool.estimatePriority(nBlocks);
 }
 
 static UniValue estimatesmartfee(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "estimatesmartfee nblocks\n"
             "\nWARNING: This interface is unstable and may disappear or "
             "change!\n"
             "\nEstimates the approximate fee per kilobyte needed for a "
             "transaction to begin\n"
             "confirmation within nblocks blocks if possible and return the "
             "number of blocks\n"
             "for which the estimate is valid.\n"
             "\nArguments:\n"
             "1. nblocks     (numeric)\n"
             "\nResult:\n"
             "{\n"
             "  \"feerate\" : x.x,     (numeric) estimate fee-per-kilobyte (in "
             "BTC)\n"
             "  \"blocks\" : n         (numeric) block number where estimate "
             "was found\n"
             "}\n"
             "\n"
             "A negative value is returned if not enough transactions and "
             "blocks\n"
             "have been observed to make an estimate for any number of blocks.\n"
             "However it will not return a value below the mempool reject fee.\n"
             "\nExample:\n" +
             HelpExampleCli("estimatesmartfee", "6"));
     }
 
     RPCTypeCheck(request.params, boost::assign::list_of(UniValue::VNUM));
 
     int nBlocks = request.params[0].get_int();
 
     UniValue result(UniValue::VOBJ);
     int answerFound;
     CFeeRate feeRate = mempool.estimateSmartFee(nBlocks, &answerFound);
     result.push_back(Pair(
         "feerate",
         feeRate == CFeeRate(0) ? -1.0 : ValueFromAmount(feeRate.GetFeePerK())));
     result.push_back(Pair("blocks", answerFound));
     return result;
 }
 
 static UniValue estimatesmartpriority(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "estimatesmartpriority nblocks\n"
             "\nDEPRECATED. WARNING: This interface is unstable and may "
             "disappear or change!\n"
             "\nEstimates the approximate priority a zero-fee transaction needs "
             "to begin\n"
             "confirmation within nblocks blocks if possible and return the "
             "number of blocks\n"
             "for which the estimate is valid.\n"
             "\nArguments:\n"
             "1. nblocks     (numeric, required)\n"
             "\nResult:\n"
             "{\n"
             "  \"priority\" : x.x,    (numeric) estimated priority\n"
             "  \"blocks\" : n         (numeric) block number where estimate "
             "was found\n"
             "}\n"
             "\n"
             "A negative value is returned if not enough transactions and "
             "blocks\n"
             "have been observed to make an estimate for any number of blocks.\n"
             "However if the mempool reject fee is set it will return 1e9 * "
             "MAX_MONEY.\n"
             "\nExample:\n" +
             HelpExampleCli("estimatesmartpriority", "6"));
     }
 
     RPCTypeCheck(request.params, boost::assign::list_of(UniValue::VNUM));
 
     int nBlocks = request.params[0].get_int();
 
     UniValue result(UniValue::VOBJ);
     int answerFound;
     double priority = mempool.estimateSmartPriority(nBlocks, &answerFound);
     result.push_back(Pair("priority", priority));
     result.push_back(Pair("blocks", answerFound));
     return result;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category   name                     actor (function)       okSafeMode
     //  ---------- ------------------------ ---------------------- ----------
     {"mining",     "getnetworkhashps",      getnetworkhashps,      true, {"nblocks", "height"}},
     {"mining",     "getmininginfo",         getmininginfo,         true, {}},
     {"mining",     "prioritisetransaction", prioritisetransaction, true, {"txid", "priority_delta", "fee_delta"}},
     {"mining",     "getblocktemplate",      getblocktemplate,      true, {"template_request"}},
     {"mining",     "submitblock",           submitblock,           true, {"hexdata", "parameters"}},
 
     {"generating", "generate",              generate,              true, {"nblocks", "maxtries"}},
     {"generating", "generatetoaddress",     generatetoaddress,     true, {"nblocks", "address", "maxtries"}},
 
     {"util",       "estimatefee",           estimatefee,           true, {"nblocks"}},
     {"util",       "estimatepriority",      estimatepriority,      true, {"nblocks"}},
     {"util",       "estimatesmartfee",      estimatesmartfee,      true, {"nblocks"}},
     {"util",       "estimatesmartpriority", estimatesmartpriority, true, {"nblocks"}},
 };
 // clang-format on
 
 void RegisterMiningRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
 }
diff --git a/src/tinyformat.h b/src/tinyformat.h
index a9c834cef..8c20f10e4 100644
--- a/src/tinyformat.h
+++ b/src/tinyformat.h
@@ -1,1058 +1,1062 @@
 // tinyformat.h
 // Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com]
 //
 // Boost Software License - Version 1.0
 //
 // Permission is hereby granted, free of charge, to any person or organization
 // obtaining a copy of the software and accompanying documentation covered by
 // this license (the "Software") to use, reproduce, display, distribute,
 // execute, and transmit the Software, and to prepare derivative works of the
 // Software, and to permit third-parties to whom the Software is furnished to
 // do so, all subject to the following:
 //
 // The copyright notices in the Software and this entire statement, including
 // the above license grant, this restriction and the following disclaimer,
 // must be included in all copies of the Software, in whole or in part, and
 // all derivative works of the Software, unless such copies or derivative
 // works are solely in the form of machine-executable object code generated by
 // a source language processor.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
 //------------------------------------------------------------------------------
 // Tinyformat: A minimal type safe printf replacement
 //
 // tinyformat.h is a type safe printf replacement library in a single C++
 // header file.  Design goals include:
 //
 // * Type safety and extensibility for user defined types.
 // * C99 printf() compatibility, to the extent possible using std::ostream
 // * Simplicity and minimalism.  A single header file to include and distribute
 //   with your projects.
 // * Augment rather than replace the standard stream formatting mechanism
 // * C++98 support, with optional C++11 niceties
 //
 //
 // Main interface example usage
 // ----------------------------
 //
 // To print a date to std::cout:
 //
 //   std::string weekday = "Wednesday";
 //   const char* month = "July";
 //   size_t day = 27;
 //   long hour = 14;
 //   int min = 44;
 //
 //   tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
 //
 // The strange types here emphasize the type safety of the interface; it is
 // possible to print a std::string using the "%s" conversion, and a
 // size_t using the "%d" conversion.  A similar result could be achieved
 // using either of the tfm::format() functions.  One prints on a user provided
 // stream:
 //
 //   tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n",
 //               weekday, month, day, hour, min);
 //
 // The other returns a std::string:
 //
 //   std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n",
 //                                  weekday, month, day, hour, min);
 //   std::cout << date;
 //
 // These are the three primary interface functions.  There is also a
 // convenience function printfln() which appends a newline to the usual result
 // of printf() for super simple logging.
 //
 //
 // User defined format functions
 // -----------------------------
 //
 // Simulating variadic templates in C++98 is pretty painful since it requires
 // writing out the same function for each desired number of arguments.  To make
 // this bearable tinyformat comes with a set of macros which are used
 // internally to generate the API, but which may also be used in user code.
 //
 // The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
 // TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
 // type/name pairs and argument names respectively when called with an integer
 // n between 1 and 16.  We can use these to define a macro which generates the
 // desired user defined function with n arguments.  To generate all 16 user
 // defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM.  For an
 // example, see the implementation of printf() at the end of the source file.
 //
 // Sometimes it's useful to be able to pass a list of format arguments through
 // to a non-template function.  The FormatList class is provided as a way to do
 // this by storing the argument list in a type-opaque way.  Continuing the
 // example from above, we construct a FormatList using makeFormatList():
 //
 //   FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour,
 //   min);
 //
 // The format list can now be passed into any non-template function and used
 // via a call to the vformat() function:
 //
 //   tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList);
 //
 //
 // Additional API information
 // --------------------------
 //
 // Error handling: Define TINYFORMAT_ERROR to customize the error handling for
 // format strings which are unsupported or have the wrong number of format
 // specifiers (calls assert() by default).
 //
 // User defined types: Uses operator<< for user defined types by default.
 // Overload formatValue() for more control.
 
 #ifndef TINYFORMAT_H_INCLUDED
 #define TINYFORMAT_H_INCLUDED
 
 namespace tinyformat {}
 //------------------------------------------------------------------------------
 // Config section.  Customize to your liking!
 
 // Namespace alias to encourage brevity
 namespace tfm = tinyformat;
 
 // Error handling; calls assert() by default.
 #define TINYFORMAT_ERROR(reasonString) throw std::runtime_error(reasonString)
 
 // Define for C++11 variadic templates which make the code shorter & more
 // general.  If you don't define this, C++11 support is autodetected below.
 #define TINYFORMAT_USE_VARIADIC_TEMPLATES
 
 //------------------------------------------------------------------------------
 // Implementation details.
 #include <algorithm>
 #include <cassert>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
 
 #ifndef TINYFORMAT_ERROR
 #define TINYFORMAT_ERROR(reason) assert(0 && reason)
 #endif
 
 #if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) &&                             \
     !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 #define TINYFORMAT_USE_VARIADIC_TEMPLATES
 #endif
 #endif
 
 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
 //  std::showpos is broken on old libstdc++ as provided with OSX.  See
 //  http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
 #define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 #endif
 
 #ifdef __APPLE__
 // Workaround OSX linker warning: xcode uses different default symbol
 // visibilities for static libs vs executables (see issue #25)
 #define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
 #else
 #define TINYFORMAT_HIDDEN
 #endif
 
 namespace tinyformat {
 
 //------------------------------------------------------------------------------
 namespace detail {
 
 // Test whether type T1 is convertible to type T2
 template <typename T1, typename T2> struct is_convertible {
 private:
     // two types of different size
     struct fail {
         char dummy[2];
     };
     struct succeed {
         char dummy;
     };
     // Try to convert a T1 to a T2 by plugging into tryConvert
     static fail tryConvert(...);
     static succeed tryConvert(const T2 &);
     static const T1 &makeT1();
 
 public:
 #ifdef _MSC_VER
 // Disable spurious loss of precision warnings in tryConvert(makeT1())
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #pragma warning(disable : 4267)
 #endif
     // Standard trick: the (...) version of tryConvert will be chosen from
     // the overload set only if the version taking a T2 doesn't match.
     // Then we compare the sizes of the return types to check which
     // function matched.  Very neat, in a disgusting kind of way :)
     static const bool value = sizeof(tryConvert(makeT1())) == sizeof(succeed);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 };
 
 // Detect when a type is not a wchar_t string
 template <typename T> struct is_wchar {
     typedef int tinyformat_wchar_is_not_supported;
 };
 template <> struct is_wchar<wchar_t *> {};
 template <> struct is_wchar<const wchar_t *> {};
 template <int n> struct is_wchar<const wchar_t[n]> {};
 template <int n> struct is_wchar<wchar_t[n]> {};
 
 // Format the value by casting to type fmtT.  This default implementation
 // should never be called.
 template <typename T, typename fmtT,
           bool convertible = is_convertible<T, fmtT>::value>
 struct formatValueAsType {
     static void invoke(std::ostream & /*out*/, const T & /*value*/) {
         assert(0);
     }
 };
 // Specialized version for types that can actually be converted to fmtT, as
 // indicated by the "convertible" template parameter.
 template <typename T, typename fmtT> struct formatValueAsType<T, fmtT, true> {
     static void invoke(std::ostream &out, const T &value) {
         out << static_cast<fmtT>(value);
     }
 };
 
 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 template <typename T, bool convertible = is_convertible<T, int>::value>
 struct formatZeroIntegerWorkaround {
     static bool invoke(std::ostream & /**/, const T & /**/) { return false; }
 };
 template <typename T> struct formatZeroIntegerWorkaround<T, true> {
     static bool invoke(std::ostream &out, const T &value) {
         if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos) {
             out << "+0";
             return true;
         }
         return false;
     }
 };
 #endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 
 // Convert an arbitrary type to integer.  The version with convertible=false
 // throws an error.
 template <typename T, bool convertible = is_convertible<T, int>::value>
 struct convertToInt {
     static int invoke(const T & /*value*/) {
         TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
                          "integer for use as variable width or precision");
         return 0;
     }
 };
 // Specialization for convertToInt when conversion is possible
 template <typename T> struct convertToInt<T, true> {
     static int invoke(const T &value) { return static_cast<int>(value); }
 };
 
 // Format at most ntrunc characters to the given stream.
 template <typename T>
 inline void formatTruncated(std::ostream &out, const T &value, int ntrunc) {
     std::ostringstream tmp;
     tmp << value;
     std::string result = tmp.str();
     out.write(result.c_str(),
               (std::min)(ntrunc, static_cast<int>(result.size())));
 }
 #define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type)                          \
     inline void formatTruncated(std::ostream &out, type *value, int ntrunc) {  \
         std::streamsize len = 0;                                               \
         while (len < ntrunc && value[len] != 0)                                \
             ++len;                                                             \
         out.write(value, len);                                                 \
     }
 // Overload for const char* and char*.  Could overload for signed & unsigned
 // char too, but these are technically unneeded for printf compatibility.
 TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
 TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char)
 #undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR
 
 } // namespace detail
 
 //------------------------------------------------------------------------------
 // Variable formatting functions.  May be overridden for user-defined types if
 // desired.
 
 /// Format a value into a stream, delegating to operator<< by default.
 ///
 /// Users may override this for their own types.  When this function is called,
 /// the stream flags will have been modified according to the format string.
 /// The format specification is provided in the range [fmtBegin, fmtEnd).  For
 /// truncating conversions, ntrunc is set to the desired maximum number of
 /// characters, for example "%.7s" calls formatValue with ntrunc = 7.
 ///
 /// By default, formatValue() uses the usual stream insertion operator
 /// operator<< to format the type T, with special cases for the %c and %p
 /// conversions.
 template <typename T>
 inline void formatValue(std::ostream &out, const char * /*fmtBegin*/,
                         const char *fmtEnd, int ntrunc, const T &value) {
 #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
     // Since we don't support printing of wchar_t using "%ls", make it fail at
     // compile time in preference to printing as a void* at runtime.
     typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported
         DummyType;
     (void)DummyType(); // avoid unused type warning with gcc-4.8
 #endif
     // The mess here is to support the %c and %p conversions: if these
     // conversions are active we try to convert the type to a char or const
     // void* respectively and format that instead of the value itself.  For the
     // %p conversion it's important to avoid dereferencing the pointer, which
     // could otherwise lead to a crash when printing a dangling (const char*).
     const bool canConvertToChar = detail::is_convertible<T, char>::value;
     const bool canConvertToVoidPtr =
         detail::is_convertible<T, const void *>::value;
     if (canConvertToChar && *(fmtEnd - 1) == 'c')
         detail::formatValueAsType<T, char>::invoke(out, value);
     else if (canConvertToVoidPtr && *(fmtEnd - 1) == 'p')
         detail::formatValueAsType<T, const void *>::invoke(out, value);
 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
     else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/
         ;
 #endif
     else if (ntrunc >= 0) {
         // Take care not to overread C strings in truncating conversions like
         // "%.4s" where at most 4 characters may be read.
         detail::formatTruncated(out, value, ntrunc);
     } else
         out << value;
 }
 
 // Overloaded version for char types to support printing as an integer
 #define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)                           \
     inline void formatValue(std::ostream &out, const char * /*fmtBegin*/,      \
                             const char *fmtEnd, int /**/, charType value) {    \
         switch (*(fmtEnd - 1)) {                                               \
             case 'u':                                                          \
             case 'd':                                                          \
             case 'i':                                                          \
             case 'o':                                                          \
             case 'X':                                                          \
             case 'x':                                                          \
                 out << static_cast<int>(value);                                \
                 break;                                                         \
             default:                                                           \
                 out << value;                                                  \
                 break;                                                         \
         }                                                                      \
     }
 // per 3.9.1: char, signed char and unsigned char are all distinct types
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
 #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR
 
 //------------------------------------------------------------------------------
 // Tools for emulating variadic templates in C++98.  The basic idea here is
 // stolen from the boost preprocessor metaprogramming library and cut down to
 // be just general enough for what we need.
 
 #define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_##n
 #define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_##n
 #define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_##n
 #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_##n
 
 // To keep it as transparent as possible, the macros below have been generated
 // using python via the excellent cog.py code generation script.  This avoids
 // the need for a bunch of complex (but more general) preprocessor tricks as
 // used in boost.preprocessor.
 //
 // To rerun the code generation in place, use `cog.py -r tinyformat.h`
 // (see http://nedbatchelder.com/code/cog).  Alternatively you can just create
 // extra versions by hand.
 
 /*[[[cog
 maxParams = 16
 
 def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
     for j in range(startInd,maxParams+1):
         list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
         cog.outl(lineTemplate % {'j':j, 'list':list})
 
 makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
                   'class T%(i)d')
 
 cog.outl()
 makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
                   'const T%(i)d& v%(i)d')
 
 cog.outl()
 makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')
 
 cog.outl()
 cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
 makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
                   'v%(i)d', startInd = 2)
 
 cog.outl()
 cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n    ' +
          ' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
 ]]]*/
 #define TINYFORMAT_ARGTYPES_1 class T1
 #define TINYFORMAT_ARGTYPES_2 class T1, class T2
 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
 #define TINYFORMAT_ARGTYPES_6                                                  \
     class T1, class T2, class T3, class T4, class T5, class T6
 #define TINYFORMAT_ARGTYPES_7                                                  \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7
 #define TINYFORMAT_ARGTYPES_8                                                  \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8
 #define TINYFORMAT_ARGTYPES_9                                                  \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9
 #define TINYFORMAT_ARGTYPES_10                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10
 #define TINYFORMAT_ARGTYPES_11                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11
 #define TINYFORMAT_ARGTYPES_12                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11, class T12
 #define TINYFORMAT_ARGTYPES_13                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11, class T12, class T13
 #define TINYFORMAT_ARGTYPES_14                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11, class T12, class T13,        \
         class T14
 #define TINYFORMAT_ARGTYPES_15                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11, class T12, class T13,        \
         class T14, class T15
 #define TINYFORMAT_ARGTYPES_16                                                 \
     class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
         class T8, class T9, class T10, class T11, class T12, class T13,        \
         class T14, class T15, class T16
 
 #define TINYFORMAT_VARARGS_1 const T1 &v1
 #define TINYFORMAT_VARARGS_2 const T1 &v1, const T2 &v2
 #define TINYFORMAT_VARARGS_3 const T1 &v1, const T2 &v2, const T3 &v3
 #define TINYFORMAT_VARARGS_4                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4
 #define TINYFORMAT_VARARGS_5                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5
 #define TINYFORMAT_VARARGS_6                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6
 #define TINYFORMAT_VARARGS_7                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7
 #define TINYFORMAT_VARARGS_8                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8
 #define TINYFORMAT_VARARGS_9                                                   \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9
 #define TINYFORMAT_VARARGS_10                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10
 #define TINYFORMAT_VARARGS_11                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11
 #define TINYFORMAT_VARARGS_12                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11, const T12 &v12
 #define TINYFORMAT_VARARGS_13                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13
 #define TINYFORMAT_VARARGS_14                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
         const T14 &v14
 #define TINYFORMAT_VARARGS_15                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
         const T14 &v14, const T15 &v15
 #define TINYFORMAT_VARARGS_16                                                  \
     const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
         const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
         const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
         const T14 &v14, const T15 &v15, const T16 &v16
 
 #define TINYFORMAT_PASSARGS_1 v1
 #define TINYFORMAT_PASSARGS_2 v1, v2
 #define TINYFORMAT_PASSARGS_3 v1, v2, v3
 #define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
 #define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
 #define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
 #define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
 #define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
 #define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 #define TINYFORMAT_PASSARGS_13                                                 \
     v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 #define TINYFORMAT_PASSARGS_14                                                 \
     v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 #define TINYFORMAT_PASSARGS_15                                                 \
     v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 #define TINYFORMAT_PASSARGS_16                                                 \
     v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 
 #define TINYFORMAT_PASSARGS_TAIL_1
 #define TINYFORMAT_PASSARGS_TAIL_2 , v2
 #define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
 #define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
 #define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
 #define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
 #define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
 #define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 #define TINYFORMAT_PASSARGS_TAIL_12                                            \
     , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 #define TINYFORMAT_PASSARGS_TAIL_13                                            \
     , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 #define TINYFORMAT_PASSARGS_TAIL_14                                            \
     , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 #define TINYFORMAT_PASSARGS_TAIL_15                                            \
     , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 #define TINYFORMAT_PASSARGS_TAIL_16                                            \
     , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 
 #define TINYFORMAT_FOREACH_ARGNUM(m)                                           \
     m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) \
         m(15) m(16)
 //[[[end]]]
 
 namespace detail {
 
 // Type-opaque holder for an argument to format(), with associated actions on
 // the type held as explicit function pointers.  This allows FormatArg's for
 // each argument to be allocated as a homogenous array inside FormatList
 // whereas a naive implementation based on inheritance does not.
 class FormatArg {
 public:
     FormatArg() {}
 
     template <typename T>
     FormatArg(const T &value)
         : m_value(static_cast<const void *>(&value)),
           m_formatImpl(&formatImpl<T>), m_toIntImpl(&toIntImpl<T>) {}
 
     void format(std::ostream &out, const char *fmtBegin, const char *fmtEnd,
                 int ntrunc) const {
         m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
     }
 
     int toInt() const { return m_toIntImpl(m_value); }
 
 private:
     template <typename T>
     TINYFORMAT_HIDDEN static void
     formatImpl(std::ostream &out, const char *fmtBegin, const char *fmtEnd,
                int ntrunc, const void *value) {
         formatValue(out, fmtBegin, fmtEnd, ntrunc,
                     *static_cast<const T *>(value));
     }
 
     template <typename T>
     TINYFORMAT_HIDDEN static int toIntImpl(const void *value) {
         return convertToInt<T>::invoke(*static_cast<const T *>(value));
     }
 
     const void *m_value;
     void (*m_formatImpl)(std::ostream &out, const char *fmtBegin,
                          const char *fmtEnd, int ntrunc, const void *value);
     int (*m_toIntImpl)(const void *value);
 };
 
 // Parse and return an integer from the string c, as atoi()
 // On return, c is set to one past the end of the integer.
 inline int parseIntAndAdvance(const char *&c) {
     int i = 0;
     for (; *c >= '0' && *c <= '9'; ++c)
         i = 10 * i + (*c - '0');
     return i;
 }
 
 // Print literal part of format string and return next format spec
 // position.
 //
 // Skips over any occurrences of '%%', printing a literal '%' to the
 // output.  The position of the first % character of the next
 // nontrivial format spec is returned, or the end of string.
 inline const char *printFormatStringLiteral(std::ostream &out,
                                             const char *fmt) {
     const char *c = fmt;
     for (;; ++c) {
         switch (*c) {
             case '\0':
                 out.write(fmt, c - fmt);
                 return c;
             case '%':
                 out.write(fmt, c - fmt);
                 if (*(c + 1) != '%') return c;
                 // for "%%", tack trailing % onto next literal section.
                 fmt = ++c;
                 break;
             default:
                 break;
         }
     }
 }
 
 // Parse a format string and set the stream state accordingly.
 //
 // The format mini-language recognized here is meant to be the one from C99,
 // with the form "%[flags][width][.precision][length]type".
 //
 // Formatting options which can't be natively represented using the ostream
 // state are returned in spacePadPositive (for space padded positive numbers)
 // and ntrunc (for truncating conversions).  argIndex is incremented if
 // necessary to pull out variable width and precision .  The function returns a
 // pointer to the character after the end of the current format spec.
 inline const char *streamStateFromFormat(std::ostream &out,
                                          bool &spacePadPositive, int &ntrunc,
                                          const char *fmtStart,
                                          const detail::FormatArg *formatters,
                                          int &argIndex, int numFormatters) {
     if (*fmtStart != '%') {
         TINYFORMAT_ERROR(
             "tinyformat: Not enough conversion specifiers in format string");
         return fmtStart;
     }
     // Reset stream state to defaults.
     out.width(0);
     out.precision(6);
     out.fill(' ');
     // Reset most flags; ignore irrelevant unitbuf & skipws.
     out.unsetf(std::ios::adjustfield | std::ios::basefield |
                std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
                std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
     bool precisionSet = false;
     bool widthSet = false;
     int widthExtra = 0;
     const char *c = fmtStart + 1;
     // 1) Parse flags
     for (;; ++c) {
         switch (*c) {
             case '#':
                 out.setf(std::ios::showpoint | std::ios::showbase);
                 continue;
             case '0':
                 // overridden by left alignment ('-' flag)
                 if (!(out.flags() & std::ios::left)) {
                     // Use internal padding so that numeric values are
                     // formatted correctly, eg -00010 rather than 000-10
                     out.fill('0');
                     out.setf(std::ios::internal, std::ios::adjustfield);
                 }
                 continue;
             case '-':
                 out.fill(' ');
                 out.setf(std::ios::left, std::ios::adjustfield);
                 continue;
             case ' ':
                 // overridden by show positive sign, '+' flag.
                 if (!(out.flags() & std::ios::showpos)) spacePadPositive = true;
                 continue;
             case '+':
                 out.setf(std::ios::showpos);
                 spacePadPositive = false;
                 widthExtra = 1;
                 continue;
             default:
                 break;
         }
         break;
     }
     // 2) Parse width
     if (*c >= '0' && *c <= '9') {
         widthSet = true;
         out.width(parseIntAndAdvance(c));
     }
     if (*c == '*') {
         widthSet = true;
         int width = 0;
         if (argIndex < numFormatters)
             width = formatters[argIndex++].toInt();
         else
             TINYFORMAT_ERROR(
                 "tinyformat: Not enough arguments to read variable width");
         if (width < 0) {
             // negative widths correspond to '-' flag set
             out.fill(' ');
             out.setf(std::ios::left, std::ios::adjustfield);
             width = -width;
         }
         out.width(width);
         ++c;
     }
     // 3) Parse precision
     if (*c == '.') {
         ++c;
         int precision = 0;
         if (*c == '*') {
             ++c;
             if (argIndex < numFormatters)
                 precision = formatters[argIndex++].toInt();
             else
                 TINYFORMAT_ERROR("tinyformat: Not enough arguments to read "
                                  "variable precision");
         } else {
             if (*c >= '0' && *c <= '9')
                 precision = parseIntAndAdvance(c);
             else if (*c == '-') // negative precisions ignored, treated as zero.
                 parseIntAndAdvance(++c);
         }
         out.precision(precision);
         precisionSet = true;
     }
     // 4) Ignore any C99 length modifier
     while (*c == 'l' || *c == 'h' || *c == 'L' || *c == 'j' || *c == 'z' ||
            *c == 't')
         ++c;
     // 5) We're up to the conversion specifier character.
     // Set stream flags based on conversion specifier (thanks to the
     // boost::format class for forging the way here).
     bool intConversion = false;
     switch (*c) {
         case 'u':
         case 'd':
         case 'i':
             out.setf(std::ios::dec, std::ios::basefield);
             intConversion = true;
             break;
         case 'o':
             out.setf(std::ios::oct, std::ios::basefield);
             intConversion = true;
             break;
         case 'X':
             out.setf(std::ios::uppercase);
+        // FALLTHROUGH
         case 'x':
         case 'p':
             out.setf(std::ios::hex, std::ios::basefield);
             intConversion = true;
             break;
         case 'E':
             out.setf(std::ios::uppercase);
+        // FALLTHROUGH
         case 'e':
             out.setf(std::ios::scientific, std::ios::floatfield);
             out.setf(std::ios::dec, std::ios::basefield);
             break;
         case 'F':
             out.setf(std::ios::uppercase);
+        // FALLTHROUGH
         case 'f':
             out.setf(std::ios::fixed, std::ios::floatfield);
             break;
         case 'G':
             out.setf(std::ios::uppercase);
+        // FALLTHROUGH
         case 'g':
             out.setf(std::ios::dec, std::ios::basefield);
             // As in boost::format, let stream decide float format.
             out.flags(out.flags() & ~std::ios::floatfield);
             break;
         case 'a':
         case 'A':
             TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
                              "are not supported");
             break;
         case 'c':
             // Handled as special case inside formatValue()
             break;
         case 's':
             if (precisionSet) ntrunc = static_cast<int>(out.precision());
             // Make %s print booleans as "true" and "false"
             out.setf(std::ios::boolalpha);
             break;
         case 'n':
             // Not supported - will cause problems!
             TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
             break;
         case '\0':
             TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
                              "terminated by end of string");
             return c;
         default:
             break;
     }
     if (intConversion && precisionSet && !widthSet) {
         // "precision" for integers gives the minimum number of digits (to be
         // padded with zeros on the left).  This isn't really supported by the
         // iostreams, but we can approximately simulate it with the width if
         // the width isn't otherwise used.
         out.width(out.precision() + widthExtra);
         out.setf(std::ios::internal, std::ios::adjustfield);
         out.fill('0');
     }
     return c + 1;
 }
 
 //------------------------------------------------------------------------------
 inline void formatImpl(std::ostream &out, const char *fmt,
                        const detail::FormatArg *formatters, int numFormatters) {
     // Saved stream state
     std::streamsize origWidth = out.width();
     std::streamsize origPrecision = out.precision();
     std::ios::fmtflags origFlags = out.flags();
     char origFill = out.fill();
 
     for (int argIndex = 0; argIndex < numFormatters; ++argIndex) {
         // Parse the format string
         fmt = printFormatStringLiteral(out, fmt);
         bool spacePadPositive = false;
         int ntrunc = -1;
         const char *fmtEnd =
             streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
                                   formatters, argIndex, numFormatters);
         if (argIndex >= numFormatters) {
             // Check args remain after reading any variable width/precision
             TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
             return;
         }
         const FormatArg &arg = formatters[argIndex];
         // Format the arg into the stream.
         if (!spacePadPositive)
             arg.format(out, fmt, fmtEnd, ntrunc);
         else {
             // The following is a special case with no direct correspondence
             // between stream formatting and the printf() behaviour.  Simulate
             // it crudely by formatting into a temporary string stream and
             // munging the resulting string.
             std::ostringstream tmpStream;
             tmpStream.copyfmt(out);
             tmpStream.setf(std::ios::showpos);
             arg.format(tmpStream, fmt, fmtEnd, ntrunc);
             std::string result = tmpStream.str(); // allocates... yuck.
             for (size_t i = 0, iend = result.size(); i < iend; ++i)
                 if (result[i] == '+') result[i] = ' ';
             out << result;
         }
         fmt = fmtEnd;
     }
 
     // Print remaining part of format string.
     fmt = printFormatStringLiteral(out, fmt);
     if (*fmt != '\0')
         TINYFORMAT_ERROR(
             "tinyformat: Too many conversion specifiers in format string");
 
     // Restore stream state
     out.width(origWidth);
     out.precision(origPrecision);
     out.flags(origFlags);
     out.fill(origFill);
 }
 
 } // namespace detail
 
 /// List of template arguments format(), held in a type-opaque way.
 ///
 /// A const reference to FormatList (typedef'd as FormatListRef) may be
 /// conveniently used to pass arguments to non-template functions: All type
 /// information has been stripped from the arguments, leaving just enough of a
 /// common interface to perform formatting as required.
 class FormatList {
 public:
     FormatList(detail::FormatArg *formatters, int N)
         : m_formatters(formatters), m_N(N) {}
 
     friend void vformat(std::ostream &out, const char *fmt,
                         const FormatList &list);
 
 private:
     const detail::FormatArg *m_formatters;
     int m_N;
 };
 
 /// Reference to type-opaque format list for passing to vformat()
 typedef const FormatList &FormatListRef;
 
 namespace detail {
 
 // Format list subclass with fixed storage to avoid dynamic allocation
 template <int N> class FormatListN : public FormatList {
 public:
 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
     template <typename... Args>
     FormatListN(const Args &... args)
         : FormatList(&m_formatterStore[0], N),
           m_formatterStore{FormatArg(args)...} {
         static_assert(sizeof...(args) == N, "Number of args must be N");
     }
 #else // C++98 version
     void init(int) {}
 #define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n)                              \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     FormatListN(TINYFORMAT_VARARGS(n)) : FormatList(&m_formatterStore[0], n) { \
         assert(n == N);                                                        \
         init(0, TINYFORMAT_PASSARGS(n));                                       \
     }                                                                          \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     void init(int i, TINYFORMAT_VARARGS(n)) {                                  \
         m_formatterStore[i] = FormatArg(v1);                                   \
         init(i + 1 TINYFORMAT_PASSARGS_TAIL(n));                               \
     }
 
     TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
 #undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
 #endif
 
 private:
     FormatArg m_formatterStore[N];
 };
 
 // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
 template <> class FormatListN<0> : public FormatList {
 public:
     FormatListN() : FormatList(0, 0) {}
 };
 
 } // namespace detail
 
 //------------------------------------------------------------------------------
 // Primary API functions
 
 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 
 /// Make type-agnostic format list from list of template arguments.
 ///
 /// The exact return type of this function is an implementation detail and
 /// shouldn't be relied upon.  Instead it should be stored as a FormatListRef:
 ///
 ///   FormatListRef formatList = makeFormatList( /*...*/ );
 template <typename... Args>
 detail::FormatListN<sizeof...(Args)> makeFormatList(const Args &... args) {
     return detail::FormatListN<sizeof...(args)>(args...);
 }
 
 #else // C++98 version
 
 inline detail::FormatListN<0> makeFormatList() {
     return detail::FormatListN<0>();
 }
 #define TINYFORMAT_MAKE_MAKEFORMATLIST(n)                                      \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) {             \
         return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n));                 \
     }
 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
 #undef TINYFORMAT_MAKE_MAKEFORMATLIST
 
 #endif
 
 /// Format list of arguments to the stream according to the given format string.
 ///
 /// The name vformat() is chosen for the semantic similarity to vprintf(): the
 /// list of format arguments is held in a single function argument.
 inline void vformat(std::ostream &out, const char *fmt, FormatListRef list) {
     detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
 }
 
 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 
 /// Format list of arguments to the stream according to given format string.
 template <typename... Args>
 void format(std::ostream &out, const char *fmt, const Args &... args) {
     vformat(out, fmt, makeFormatList(args...));
 }
 
 /// Format list of arguments according to the given format string and return
 /// the result as a string.
 template <typename... Args>
 std::string format(const char *fmt, const Args &... args) {
     std::ostringstream oss;
     format(oss, fmt, args...);
     return oss.str();
 }
 
 /// Format list of arguments to std::cout, according to the given format string
 template <typename... Args> void printf(const char *fmt, const Args &... args) {
     format(std::cout, fmt, args...);
 }
 
 template <typename... Args>
 void printfln(const char *fmt, const Args &... args) {
     format(std::cout, fmt, args...);
     std::cout << '\n';
 }
 
 #else // C++98 version
 
 inline void format(std::ostream &out, const char *fmt) {
     vformat(out, fmt, makeFormatList());
 }
 
 inline std::string format(const char *fmt) {
     std::ostringstream oss;
     format(oss, fmt);
     return oss.str();
 }
 
 inline void printf(const char *fmt) {
     format(std::cout, fmt);
 }
 
 inline void printfln(const char *fmt) {
     format(std::cout, fmt);
     std::cout << '\n';
 }
 
 #define TINYFORMAT_MAKE_FORMAT_FUNCS(n)                                        \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     void format(std::ostream &out, const char *fmt, TINYFORMAT_VARARGS(n)) {   \
         vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n)));             \
     }                                                                          \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     std::string format(const char *fmt, TINYFORMAT_VARARGS(n)) {               \
         std::ostringstream oss;                                                \
         format(oss, fmt, TINYFORMAT_PASSARGS(n));                              \
         return oss.str();                                                      \
     }                                                                          \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     void printf(const char *fmt, TINYFORMAT_VARARGS(n)) {                      \
         format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                        \
     }                                                                          \
                                                                                \
     template <TINYFORMAT_ARGTYPES(n)>                                          \
     void printfln(const char *fmt, TINYFORMAT_VARARGS(n)) {                    \
         format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                        \
         std::cout << '\n';                                                     \
     }
 
 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
 #undef TINYFORMAT_MAKE_FORMAT_FUNCS
 
 #endif
 
 // Added for Bitcoin Core
 template <typename... Args>
 std::string format(const std::string &fmt, const Args &... args) {
     std::ostringstream oss;
     format(oss, fmt.c_str(), args...);
     return oss.str();
 }
 
 } // namespace tinyformat
 
 #define strprintf tfm::format
 
 #endif // TINYFORMAT_H_INCLUDED