diff --git a/doc/release-notes.md b/doc/release-notes.md
index 145a08e85..3be26adad 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,13 +1,17 @@
 Bitcoin ABC version 0.21.9 is now available from:
 
   <https://download.bitcoinabc.org/0.21.9/>
 
 This release includes the following features and fixes:
 - Improve management of maxfee by the wallet.
 
 Wallet changes
 --------------
 When creating a transaction with a fee above `-maxtxfee` (default 0.1 BCH),
 the RPC commands `walletcreatefundedpsbt` and  `fundrawtransaction` will now fail
 instead of rounding down the fee. Beware that the `feeRate` argument is specified
 in BCH per kilobyte, not satoshi per byte.
+
+RPC changes
+-----------
+The `getblockstats` RPC is faster for fee calculation by using BlockUndo data. Also, `-txindex` is no longer required and `getblockstats` works for all non-pruned blocks.
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index abae85ceb..ed7efee64 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1,2734 +1,2733 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 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 <rpc/blockchain.h>
 
 #include <amount.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <hash.h>
 #include <index/txindex.h>
 #include <key_io.h>
 #include <node/coinstats.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
 #include <sync.h>
 #include <txdb.h>
 #include <txmempool.h>
+#include <undo.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/validation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <versionbitsinfo.h> // For VersionBitsDeploymentInfo
 #include <warnings.h>
 
 #include <boost/thread/thread.hpp> // boost::thread::interrupt
 
 #include <condition_variable>
 #include <cstdint>
 #include <memory>
 #include <mutex>
 
 struct CUpdatedBlock {
     uint256 hash;
     int height;
 };
 
 static Mutex cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock;
 
 /**
  * Calculate the difficulty for a given block index.
  */
 double GetDifficulty(const CBlockIndex *blockindex) {
     assert(blockindex);
 
     int nShift = (blockindex->nBits >> 24) & 0xff;
     double dDiff = double(0x0000ffff) / double(blockindex->nBits & 0x00ffffff);
 
     while (nShift < 29) {
         dDiff *= 256.0;
         nShift++;
     }
     while (nShift > 29) {
         dDiff /= 256.0;
         nShift--;
     }
 
     return dDiff;
 }
 
 static int ComputeNextBlockAndDepth(const CBlockIndex *tip,
                                     const CBlockIndex *blockindex,
                                     const CBlockIndex *&next) {
     next = tip->GetAncestor(blockindex->nHeight + 1);
     if (next && next->pprev == blockindex) {
         return tip->nHeight - blockindex->nHeight + 1;
     }
     next = nullptr;
     return blockindex == tip ? 1 : -1;
 }
 
 UniValue blockheaderToJSON(const CBlockIndex *tip,
                            const CBlockIndex *blockindex) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", blockindex->nVersion);
     result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));
     result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
     result.pushKV("time", int64_t(blockindex->nTime));
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(blockindex->nNonce));
     result.pushKV("bits", strprintf("%08x", blockindex->nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 UniValue blockToJSON(const CBlock &block, const CBlockIndex *tip,
                      const CBlockIndex *blockindex, bool txDetails) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", block.nVersion);
     result.pushKV("versionHex", strprintf("%08x", block.nVersion));
     result.pushKV("merkleroot", block.hashMerkleRoot.GetHex());
     UniValue txs(UniValue::VARR);
     for (const auto &tx : block.vtx) {
         if (txDetails) {
             UniValue objTx(UniValue::VOBJ);
             TxToUniv(*tx, uint256(), objTx, true, RPCSerializationFlags());
             txs.push_back(objTx);
         } else {
             txs.push_back(tx->GetId().GetHex());
         }
     }
     result.pushKV("tx", txs);
     result.pushKV("time", block.GetBlockTime());
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(block.nNonce));
     result.pushKV("bits", strprintf("%08x", block.nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 static UniValue getblockcount(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getblockcount",
             "\nReturns the number of blocks in the longest blockchain.\n",
             {},
             RPCResult{"n    (numeric) The current block count\n"},
             RPCExamples{HelpExampleCli("getblockcount", "") +
                         HelpExampleRpc("getblockcount", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
     return ::ChainActive().Height();
 }
 
 static UniValue getbestblockhash(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getbestblockhash",
             "\nReturns the hash of the best (tip) block in the "
             "longest blockchain.\n",
             {},
             RPCResult{"\"hex\"      (string) the block hash, hex-encoded\n"},
             RPCExamples{HelpExampleCli("getbestblockhash", "") +
                         HelpExampleRpc("getbestblockhash", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
     return ::ChainActive().Tip()->GetBlockHash().GetHex();
 }
 
 UniValue getfinalizedblockhash(const Config &config,
                                const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getfinalizedblockhash",
             "\nReturns the hash of the currently finalized block\n",
             {},
             RPCResult{"\"hex\"      (string) the block hash hex-encoded\n"},
             RPCExamples{HelpExampleCli("getfinalizedblockhash", "") +
                         HelpExampleRpc("getfinalizedblockhash", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
     const CBlockIndex *blockIndexFinalized = GetFinalizedBlock();
     if (blockIndexFinalized) {
         return blockIndexFinalized->GetBlockHash().GetHex();
     }
     return UniValue(UniValue::VSTR);
 }
 
 void RPCNotifyBlockChange(bool ibd, const CBlockIndex *pindex) {
     if (pindex) {
         std::lock_guard<std::mutex> lock(cs_blockchange);
         latestblock.hash = pindex->GetBlockHash();
         latestblock.height = pindex->nHeight;
     }
     cond_blockchange.notify_all();
 }
 
 static UniValue waitfornewblock(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "waitfornewblock",
             "\nWaits for a specific new block and returns useful "
             "info about it.\n"
             "\nReturns the current block on timeout or exit.\n",
             {
                 {"timeout", RPCArg::Type::NUM, /* default */ "0",
                  "Time in milliseconds to wait for a response. 0 indicates no "
                  "timeout."},
             },
             RPCResult{"{                           (json object)\n"
                       "  \"hash\" : {       (string) The blockhash\n"
                       "  \"height\" : {     (int) Block height\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("waitfornewblock", "1000") +
                         HelpExampleRpc("waitfornewblock", "1000")},
         }
                                      .ToString());
     }
     int timeout = 0;
     if (!request.params[0].isNull()) {
         timeout = request.params[0].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         block = latestblock;
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout), [&block] {
                     return latestblock.height != block.height ||
                            latestblock.hash != block.hash || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(lock, [&block] {
                 return latestblock.height != block.height ||
                        latestblock.hash != block.hash || !IsRPCRunning();
             });
         }
         block = latestblock;
     }
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue waitforblock(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "waitforblock",
             "\nWaits for a specific new block and returns useful "
             "info about it.\n"
             "\nReturns the current block on timeout or exit.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "Block hash to wait for."},
                 {"timeout", RPCArg::Type::NUM, /* default */ "0",
                  "Time in milliseconds to wait for a response. 0 "
                  "indicates no timeout."},
             },
             RPCResult{"{                           (json object)\n"
                       "  \"hash\" : {       (string) The blockhash\n"
                       "  \"height\" : {     (int) Block height\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("waitforblock",
                                        "\"0000000000079f8ef3d2c688c244eb7a4"
                                        "570b24c9ed7b4a8c619eb02596f8862\", "
                                        "1000") +
                         HelpExampleRpc("waitforblock",
                                        "\"0000000000079f8ef3d2c688c244eb7a4"
                                        "570b24c9ed7b4a8c619eb02596f8862\", "
                                        "1000")},
         }
                                      .ToString());
     }
 
     int timeout = 0;
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     if (!request.params[1].isNull()) {
         timeout = request.params[1].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout), [&hash] {
                     return latestblock.hash == hash || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(lock, [&hash] {
                 return latestblock.hash == hash || !IsRPCRunning();
             });
         }
         block = latestblock;
     }
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue waitforblockheight(const Config &config,
                                    const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "waitforblockheight",
             "\nWaits for (at least) block height and returns the "
             "height and hash\nof the current tip.\n"
             "\nReturns the current block on timeout or exit.\n",
             {
                 {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "Block height to wait for."},
                 {"timeout", RPCArg::Type::NUM, /* default */ "0",
                  "Time in milliseconds to wait for a response. 0 "
                  "indicates no timeout."},
             },
             RPCResult{"{                           (json object)\n"
                       "  \"hash\" : {       (string) The blockhash\n"
                       "  \"height\" : {     (int) Block height\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("waitforblockheight", "\"100\", 1000") +
                         HelpExampleRpc("waitforblockheight", "\"100\", 1000")},
         }
                                      .ToString());
     }
 
     int timeout = 0;
 
     int height = request.params[0].get_int();
 
     if (!request.params[1].isNull()) {
         timeout = request.params[1].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout), [&height] {
                     return latestblock.height >= height || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(lock, [&height] {
                 return latestblock.height >= height || !IsRPCRunning();
             });
         }
         block = latestblock;
     }
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue
 syncwithvalidationinterfacequeue(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(RPCHelpMan{
             "syncwithvalidationinterfacequeue",
             "\nWaits for the validation interface queue to catch up on "
             "everything that was there when we entered this function.\n",
             {},
             RPCResults{},
             RPCExamples{HelpExampleCli("syncwithvalidationinterfacequeue", "") +
                         HelpExampleRpc("syncwithvalidationinterfacequeue", "")},
         }
                                      .ToString());
     }
     SyncWithValidationInterfaceQueue();
     return NullUniValue;
 }
 
 static UniValue getdifficulty(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getdifficulty",
             "\nReturns the proof-of-work difficulty as a multiple of the "
             "minimum difficulty.\n",
             {},
             RPCResult{"n.nnn       (numeric) the proof-of-work difficulty as a "
                       "multiple of the minimum difficulty.\n"},
             RPCExamples{HelpExampleCli("getdifficulty", "") +
                         HelpExampleRpc("getdifficulty", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
     return GetDifficulty(::ChainActive().Tip());
 }
 
 static std::string EntryDescriptionString() {
     return "    \"size\" : n,             (numeric) transaction size.\n"
            "    \"fee\" : n,              (numeric) transaction fee in " +
            CURRENCY_UNIT + "(DEPRECATED)" +
            "\n"
            "    \"modifiedfee\" : n,      (numeric) transaction fee with fee "
            "deltas used for mining priority (DEPRECATED)\n"
            "    \"time\" : n,             (numeric) local time transaction "
            "entered pool in seconds since 1 Jan 1970 GMT\n"
            "    \"height\" : n,           (numeric) block height when "
            "transaction entered pool\n"
            "    \"descendantcount\" : n,  (numeric) number of in-mempool "
            "descendant transactions (including this one)\n"
            "    \"descendantsize\" : n,   (numeric) transaction size "
            "of in-mempool descendants (including this one)\n"
            "    \"descendantfees\" : n,   (numeric) modified fees (see above) "
            "of in-mempool descendants (including this one) (DEPRECATED)\n"
            "    \"ancestorcount\" : n,    (numeric) number of in-mempool "
            "ancestor transactions (including this one)\n"
            "    \"ancestorsize\" : n,     (numeric) transaction size "
            "of in-mempool ancestors (including this one)\n"
            "    \"ancestorfees\" : n,     (numeric) modified fees (see above) "
            "of in-mempool ancestors (including this one) (DEPRECATED)\n"
            "    \"fees\" : {\n"
            "        \"base\" : n,         (numeric) transaction fee in " +
            CURRENCY_UNIT +
            "\n"
            "        \"modified\" : n,     (numeric) transaction fee with fee "
            "deltas used for mining priority in " +
            CURRENCY_UNIT +
            "\n"
            "        \"ancestor\" : n,     (numeric) modified fees (see above) "
            "of in-mempool ancestors (including this one) in " +
            CURRENCY_UNIT +
            "\n"
            "        \"descendant\" : n,   (numeric) modified fees (see above) "
            "of in-mempool descendants (including this one) in " +
            CURRENCY_UNIT +
            "\n"
            "    }\n"
            "    \"depends\" : [           (array) unconfirmed transactions "
            "used as inputs for this transaction\n"
            "        \"transactionid\",    (string) parent transaction id\n"
            "       ... ]\n"
            "    \"spentby\" : [           (array) unconfirmed transactions "
            "spending outputs from this transaction\n"
            "        \"transactionid\",    (string) child transaction id\n"
            "       ... ]\n";
 }
 
 static void entryToJSON(const CTxMemPool &pool, UniValue &info,
                         const CTxMemPoolEntry &e)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     AssertLockHeld(pool.cs);
 
     UniValue fees(UniValue::VOBJ);
     fees.pushKV("base", ValueFromAmount(e.GetFee()));
     fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
     fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
     fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
     info.pushKV("fees", fees);
 
     info.pushKV("size", (int)e.GetTxSize());
     info.pushKV("fee", ValueFromAmount(e.GetFee()));
     info.pushKV("modifiedfee", ValueFromAmount(e.GetModifiedFee()));
     info.pushKV("time", e.GetTime());
     info.pushKV("height", (int)e.GetHeight());
     info.pushKV("descendantcount", e.GetCountWithDescendants());
     info.pushKV("descendantsize", e.GetSizeWithDescendants());
     info.pushKV("descendantfees", e.GetModFeesWithDescendants() / SATOSHI);
     info.pushKV("ancestorcount", e.GetCountWithAncestors());
     info.pushKV("ancestorsize", e.GetSizeWithAncestors());
     info.pushKV("ancestorfees", e.GetModFeesWithAncestors() / SATOSHI);
     const CTransaction &tx = e.GetTx();
     std::set<std::string> setDepends;
     for (const CTxIn &txin : tx.vin) {
         if (pool.exists(txin.prevout.GetTxId())) {
             setDepends.insert(txin.prevout.GetTxId().ToString());
         }
     }
 
     UniValue depends(UniValue::VARR);
     for (const std::string &dep : setDepends) {
         depends.push_back(dep);
     }
 
     info.pushKV("depends", depends);
 
     UniValue spent(UniValue::VARR);
     const CTxMemPool::txiter &it = pool.mapTx.find(tx.GetId());
     const CTxMemPool::setEntries &setChildren = pool.GetMemPoolChildren(it);
     for (CTxMemPool::txiter childiter : setChildren) {
         spent.push_back(childiter->GetTx().GetId().ToString());
     }
 
     info.pushKV("spentby", spent);
 }
 
 UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose) {
     if (verbose) {
         LOCK(pool.cs);
         UniValue o(UniValue::VOBJ);
         for (const CTxMemPoolEntry &e : pool.mapTx) {
             const uint256 &txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(pool, info, e);
             // Mempool has unique entries so there is no advantage in using
             // UniValue::pushKV, which checks if the key already exists in O(N).
             // UniValue::__pushKV is used instead which currently is O(1).
             o.__pushKV(txid.ToString(), info);
         }
         return o;
     } else {
         std::vector<uint256> vtxids;
         pool.queryHashes(vtxids);
 
         UniValue a(UniValue::VARR);
         for (const uint256 &txid : vtxids) {
             a.push_back(txid.ToString());
         }
 
         return a;
     }
 }
 
 static UniValue getrawmempool(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "getrawmempool",
             "\nReturns all transaction ids in memory pool as a json "
             "array of string transaction ids.\n"
             "\nHint: use getmempoolentry to fetch a specific "
             "transaction from the mempool.\n",
             {
                 {"verbose", RPCArg::Type::BOOL, /* default */ "false",
                  "True for a json object, false for array of "
                  "transaction ids"},
             },
             RPCResult{"for verbose = false",
                       "[                     (json array of string)\n"
                       "  \"transactionid\"     (string) The transaction id\n"
                       "  ,...\n"
                       "]\n"
                       "\nResult: (for verbose = true):\n"
                       "{                           (json object)\n"
                       "  \"transactionid\" : {       (json object)\n" +
                           EntryDescriptionString() +
                           "  }, ...\n"
                           "}\n"},
             RPCExamples{HelpExampleCli("getrawmempool", "true") +
                         HelpExampleRpc("getrawmempool", "true")},
         }
                                      .ToString());
     }
 
     bool fVerbose = false;
     if (!request.params[0].isNull()) {
         fVerbose = request.params[0].get_bool();
     }
 
     return MempoolToJSON(::g_mempool, fVerbose);
 }
 
 static UniValue getmempoolancestors(const Config &config,
                                     const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getmempoolancestors",
             "\nIf txid is in the mempool, returns all in-mempool "
             "ancestors.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction id (must be in mempool)"},
                 {"verbose", RPCArg::Type::BOOL, /* default */ "false",
                  "True for a json object, false for array of "
                  "transaction ids"},
             },
             {
                 RPCResult{
                     "for verbose = false",
                     "[                       (json array of strings)\n"
                     "  \"transactionid\"           (string) The transaction id "
                     "of an in-mempool ancestor transaction\n"
                     "  ,...\n"
                     "]\n"},
                 RPCResult{"for verbose = true",
                           "{                           (json object)\n"
                           "  \"transactionid\" : {       (json object)\n" +
                               EntryDescriptionString() +
                               "  }, ...\n"
                               "}\n"},
             },
             RPCExamples{HelpExampleCli("getmempoolancestors", "\"mytxid\"") +
                         HelpExampleRpc("getmempoolancestors", "\"mytxid\"")},
         }
                                      .ToString());
     }
 
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     LOCK(g_mempool.cs);
 
     CTxMemPool::txiter it = g_mempool.mapTx.find(txid);
     if (it == g_mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     CTxMemPool::setEntries setAncestors;
     uint64_t noLimit = std::numeric_limits<uint64_t>::max();
     std::string dummy;
     g_mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit, noLimit,
                                         noLimit, noLimit, dummy, false);
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
         for (CTxMemPool::txiter ancestorIt : setAncestors) {
             o.push_back(ancestorIt->GetTx().GetId().ToString());
         }
 
         return o;
     } else {
         UniValue o(UniValue::VOBJ);
         for (CTxMemPool::txiter ancestorIt : setAncestors) {
             const CTxMemPoolEntry &e = *ancestorIt;
             const TxId &_txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(::g_mempool, info, e);
             o.pushKV(_txid.ToString(), info);
         }
         return o;
     }
 }
 
 static UniValue getmempooldescendants(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getmempooldescendants",
             "\nIf txid is in the mempool, returns all in-mempool "
             "descendants.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction id (must be in mempool)"},
                 {"verbose", RPCArg::Type::BOOL, /* default */ "false",
                  "True for a json object, false for array of "
                  "transaction ids"},
             },
             {
                 RPCResult{
                     "for verbose = false",
                     "[                       (json array of strings)\n"
                     "  \"transactionid\"           (string) The transaction id "
                     "of an in-mempool descendant transaction\n"
                     "  ,...\n"
                     "]\n"},
                 RPCResult{"for verbose = true",
                           "{                           (json object)\n"
                           "  \"transactionid\" : {       (json object)\n" +
                               EntryDescriptionString() +
                               "  }, ...\n"
                               "}\n"},
             },
             RPCExamples{HelpExampleCli("getmempooldescendants", "\"mytxid\"") +
                         HelpExampleRpc("getmempooldescendants", "\"mytxid\"")},
         }
                                      .ToString());
     }
 
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     LOCK(g_mempool.cs);
 
     CTxMemPool::txiter it = g_mempool.mapTx.find(txid);
     if (it == g_mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     CTxMemPool::setEntries setDescendants;
     g_mempool.CalculateDescendants(it, setDescendants);
     // CTxMemPool::CalculateDescendants will include the given tx
     setDescendants.erase(it);
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
         for (CTxMemPool::txiter descendantIt : setDescendants) {
             o.push_back(descendantIt->GetTx().GetId().ToString());
         }
 
         return o;
     } else {
         UniValue o(UniValue::VOBJ);
         for (CTxMemPool::txiter descendantIt : setDescendants) {
             const CTxMemPoolEntry &e = *descendantIt;
             const TxId &_txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(::g_mempool, info, e);
             o.pushKV(_txid.ToString(), info);
         }
         return o;
     }
 }
 
 static UniValue getmempoolentry(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "getmempoolentry",
             "\nReturns mempool data for given transaction\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction id (must be in mempool)"},
             },
             RPCResult{"{                           (json object)\n" +
                       EntryDescriptionString() + "}\n"},
             RPCExamples{HelpExampleCli("getmempoolentry", "\"mytxid\"") +
                         HelpExampleRpc("getmempoolentry", "\"mytxid\"")},
         }
                                      .ToString());
     }
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     LOCK(g_mempool.cs);
 
     CTxMemPool::txiter it = g_mempool.mapTx.find(txid);
     if (it == g_mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     const CTxMemPoolEntry &e = *it;
     UniValue info(UniValue::VOBJ);
     entryToJSON(::g_mempool, info, e);
     return info;
 }
 
 static UniValue getblockhash(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "getblockhash",
             "\nReturns hash of block in best-block-chain at height "
             "provided.\n",
             {
                 {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "The height index"},
             },
             RPCResult{"\"hash\"         (string) The block hash\n"},
             RPCExamples{HelpExampleCli("getblockhash", "1000") +
                         HelpExampleRpc("getblockhash", "1000")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     int nHeight = request.params[0].get_int();
     if (nHeight < 0 || nHeight > ::ChainActive().Height()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
     }
 
     CBlockIndex *pblockindex = ::ChainActive()[nHeight];
     return pblockindex->GetBlockHash().GetHex();
 }
 
 static UniValue getblockheader(const Config &config,
                                const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getblockheader",
             "\nIf verbose is false, returns a string that is "
             "serialized, hex-encoded data for blockheader 'hash'.\n"
             "If verbose is true, returns an Object with information "
             "about blockheader <hash>.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The block hash"},
                 {"verbose", RPCArg::Type::BOOL, /* default */ "true",
                  "true for a json object, false for the hex-encoded data"},
             },
             {
                 RPCResult{
                     "for verbose = true",
                     "{\n"
                     "  \"hash\" : \"hash\",     (string) the block hash (same "
                     "as provided)\n"
                     "  \"confirmations\" : n,   (numeric) The number of "
                     "confirmations, or -1 if the block is not on the main "
                     "chain\n"
                     "  \"height\" : n,          (numeric) The block height or "
                     "index\n"
                     "  \"version\" : n,         (numeric) The block version\n"
                     "  \"versionHex\" : \"00000000\", (string) The block "
                     "version formatted in hexadecimal\n"
                     "  \"merkleroot\" : \"xxxx\", (string) The merkle root\n"
                     "  \"time\" : ttt,          (numeric) The block time in "
                     "seconds since epoch (Jan 1 1970 GMT)\n"
                     "  \"mediantime\" : ttt,    (numeric) The median block "
                     "time in seconds since epoch (Jan 1 1970 GMT)\n"
                     "  \"nonce\" : n,           (numeric) The nonce\n"
                     "  \"bits\" : \"1d00ffff\", (string) The bits\n"
                     "  \"difficulty\" : x.xxx,  (numeric) The difficulty\n"
                     "  \"chainwork\" : \"0000...1f3\"     (string) Expected "
                     "number of hashes required to produce the current chain "
                     "(in hex)\n"
                     "  \"nTx\" : n,             (numeric) The number of "
                     "transactions in the block.\n"
                     "  \"previousblockhash\" : \"hash\",  (string) The hash of "
                     "the previous block\n"
                     "  \"nextblockhash\" : \"hash\",      (string) The hash of "
                     "the next block\n"
                     "}\n"},
                 RPCResult{"for verbose=false",
                           "\"data\"             (string) A string that is "
                           "serialized, hex-encoded data for block 'hash'.\n"},
             },
             RPCExamples{HelpExampleCli("getblockheader",
                                        "\"00000000c937983704a73af28acdec3"
                                        "7b049d214adbda81d7e2a3dd146f6ed09"
                                        "\"") +
                         HelpExampleRpc("getblockheader",
                                        "\"00000000c937983704a73af28acdec3"
                                        "7b049d214adbda81d7e2a3dd146f6ed09"
                                        "\"")},
         }
                                      .ToString());
     }
 
     BlockHash hash(ParseHashV(request.params[0], "hash"));
 
     bool fVerbose = true;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     const CBlockIndex *pblockindex;
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         tip = ::ChainActive().Tip();
     }
 
     if (!pblockindex) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
     }
 
     if (!fVerbose) {
         CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
         ssBlock << pblockindex->GetBlockHeader();
         std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
         return strHex;
     }
 
     return blockheaderToJSON(tip, pblockindex);
 }
 
 static CBlock GetBlockChecked(const Config &config,
                               const CBlockIndex *pblockindex) {
     CBlock block;
     if (IsBlockPruned(pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Block not available (pruned data)");
     }
 
     if (!ReadBlockFromDisk(block, pblockindex,
                            config.GetChainParams().GetConsensus())) {
         // Block not found on disk. This could be because we have the block
         // header in our index but don't have the block (for example if a
         // non-whitelisted node sends us an unrequested long chain of valid
         // blocks, we add the headers to our index, but don't accept the block).
         throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");
     }
 
     return block;
 }
 
+static CBlockUndo GetUndoChecked(const CBlockIndex *pblockindex) {
+    CBlockUndo blockUndo;
+    if (IsBlockPruned(pblockindex)) {
+        throw JSONRPCError(RPC_MISC_ERROR,
+                           "Undo data not available (pruned data)");
+    }
+
+    if (!UndoReadFromDisk(blockUndo, pblockindex)) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");
+    }
+
+    return blockUndo;
+}
+
 static UniValue getblock(const Config &config, const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "getblock",
         "\nIf verbosity is 0 or false, returns a string that is "
         "serialized, hex-encoded data for block 'hash'.\n"
         "If verbosity is 1 or true, returns an Object with information "
         "about block <hash>.\n"
         "If verbosity is 2, returns an Object with information about "
         "block <hash> and information about each transaction.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbosity", RPCArg::Type::NUM, /* default */ "1",
              "0 for hex-encoded data, 1 for a json object, and 2 for "
              "json object with transaction data"},
         },
         {
             RPCResult{"for verbosity = 0",
                       "\"data\"                   (string) A string that is "
                       "serialized, hex-encoded data for block 'hash'.\n"},
             RPCResult{
                 "for verbosity = 1",
                 "{\n"
                 "  \"hash\" : \"hash\",       (string) The block hash "
                 "(same as provided)\n"
                 "  \"confirmations\" : n,   (numeric) The number of "
                 "confirmations, or -1 if the block is not on the main "
                 "chain\n"
                 "  \"size\" : n,            (numeric) The block size\n"
                 "  \"height\" : n,          (numeric) The block height or "
                 "index\n"
                 "  \"version\" : n,         (numeric) The block version\n"
                 "  \"versionHex\" : \"00000000\", (string) The block "
                 "version formatted in hexadecimal\n"
                 "  \"merkleroot\" : \"xxxx\", (string) The merkle root\n"
                 "  \"tx\" : [               (array of string) The "
                 "transaction ids\n"
                 "     \"transactionid\"     (string) The transaction id\n"
                 "     ,...\n"
                 "  ],\n"
                 "  \"time\" : ttt,          (numeric) The block time in "
                 "seconds since epoch (Jan 1 1970 GMT)\n"
                 "  \"mediantime\" : ttt,    (numeric) The median block "
                 "time in seconds since epoch (Jan 1 1970 GMT)\n"
                 "  \"nonce\" : n,           (numeric) The nonce\n"
                 "  \"bits\" : \"1d00ffff\",   (string) The bits\n"
                 "  \"difficulty\" : x.xxx,  (numeric) The difficulty\n"
                 "  \"chainwork\" : \"xxxx\",  (string) Expected number of "
                 "hashes required to produce the chain up to this block (in "
                 "hex)\n"
                 "  \"nTx\" : n,             (numeric) The number of "
                 "transactions in the block.\n"
                 "  \"previousblockhash\" : \"hash\",  (string) The hash of "
                 "the previous block\n"
                 "  \"nextblockhash\" : \"hash\"       (string) The hash of "
                 "the next block\n"
                 "}\n"},
             RPCResult{
                 "for verbosity = 2",
                 "{\n"
                 "  ...,                   Same output as verbosity = 1\n"
                 "  \"tx\" : [               (array of Objects) The "
                 "transactions in the format of the getrawtransaction RPC; "
                 "different from verbosity = 1 \"tx\" result\n"
                 "    ...\n"
                 "  ],\n"
                 "  ...                    Same output as verbosity = 1\n"
                 "}\n"},
         },
         RPCExamples{
             HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"") +
             HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"")},
     };
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size())) {
         throw std::runtime_error(help.ToString());
     }
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     int verbosity = 1;
     if (!request.params[1].isNull()) {
         if (request.params[1].isNum()) {
             verbosity = request.params[1].get_int();
         } else {
             verbosity = request.params[1].get_bool() ? 1 : 0;
         }
     }
 
     CBlock block;
     const CBlockIndex *pblockindex;
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         tip = ::ChainActive().Tip();
 
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         block = GetBlockChecked(config, pblockindex);
     }
 
     if (verbosity <= 0) {
         CDataStream ssBlock(SER_NETWORK,
                             PROTOCOL_VERSION | RPCSerializationFlags());
         ssBlock << block;
         std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
         return strHex;
     }
 
     return blockToJSON(block, tip, pblockindex, verbosity >= 2);
 }
 
 static UniValue pruneblockchain(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "pruneblockchain",
             "",
             {
                 {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "The block height to prune up to. May be set to a discrete "
                  "height, or a unix timestamp\n"
                  "                  to prune blocks whose block time is at "
                  "least 2 hours older than the provided timestamp."},
             },
             RPCResult{"n    (numeric) Height of the last block pruned.\n"},
             RPCExamples{HelpExampleCli("pruneblockchain", "1000") +
                         HelpExampleRpc("pruneblockchain", "1000")},
         }
                                      .ToString());
     }
 
     if (!fPruneMode) {
         throw JSONRPCError(
             RPC_MISC_ERROR,
             "Cannot prune blocks because node is not in prune mode.");
     }
 
     LOCK(cs_main);
 
     int heightParam = request.params[0].get_int();
     if (heightParam < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative block height.");
     }
 
     // Height value more than a billion is too high to be a block height, and
     // too low to be a block time (corresponds to timestamp from Sep 2001).
     if (heightParam > 1000000000) {
         // Add a 2 hour buffer to include blocks which might have had old
         // timestamps
         CBlockIndex *pindex = ::ChainActive().FindEarliestAtLeast(
             heightParam - TIMESTAMP_WINDOW, 0);
         if (!pindex) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Could not find block with at least the specified timestamp.");
         }
         heightParam = pindex->nHeight;
     }
 
     unsigned int height = (unsigned int)heightParam;
     unsigned int chainHeight = (unsigned int)::ChainActive().Height();
     if (chainHeight < config.GetChainParams().PruneAfterHeight()) {
         throw JSONRPCError(RPC_MISC_ERROR,
                            "Blockchain is too short for pruning.");
     } else if (height > chainHeight) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Blockchain is shorter than the attempted prune height.");
     } else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {
         LogPrint(BCLog::RPC, "Attempt to prune blocks close to the tip. "
                              "Retaining the minimum number of blocks.\n");
         height = chainHeight - MIN_BLOCKS_TO_KEEP;
     }
 
     PruneBlockFilesManual(height);
     return uint64_t(height);
 }
 
 static UniValue gettxoutsetinfo(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "gettxoutsetinfo",
             "\nReturns statistics about the unspent transaction output set.\n"
             "Note this call may take some time.\n",
             {},
             RPCResult{
                 "{\n"
                 "  \"height\":n,     (numeric) The current block height "
                 "(index)\n"
                 "  \"bestblock\": \"hex\",   (string) the best block hash hex\n"
                 "  \"transactions\": n,      (numeric) The number of "
                 "transactions\n"
                 "  \"txouts\": n,            (numeric) The number of output "
                 "transactions\n"
                 "  \"bogosize\": n,          (numeric) A database-independent "
                 "metric for UTXO set size\n"
                 "  \"hash_serialized\": \"hash\",   (string) The serialized "
                 "hash\n"
                 "  \"disk_size\": n,         (numeric) The estimated size of "
                 "the chainstate on disk\n"
                 "  \"total_amount\": x.xxx          (numeric) The total "
                 "amount\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("gettxoutsetinfo", "") +
                         HelpExampleRpc("gettxoutsetinfo", "")},
         }
                                      .ToString());
     }
 
     UniValue ret(UniValue::VOBJ);
 
     CCoinsStats stats;
     ::ChainstateActive().ForceFlushStateToDisk();
     if (GetUTXOStats(pcoinsdbview.get(), stats)) {
         ret.pushKV("height", int64_t(stats.nHeight));
         ret.pushKV("bestblock", stats.hashBlock.GetHex());
         ret.pushKV("transactions", int64_t(stats.nTransactions));
         ret.pushKV("txouts", int64_t(stats.nTransactionOutputs));
         ret.pushKV("bogosize", int64_t(stats.nBogoSize));
         ret.pushKV("hash_serialized", stats.hashSerialized.GetHex());
         ret.pushKV("disk_size", stats.nDiskSize);
         ret.pushKV("total_amount", ValueFromAmount(stats.nTotalAmount));
     } else {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
     }
     return ret;
 }
 
 UniValue gettxout(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "gettxout",
             "\nReturns details about an unspent transaction output.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction id"},
                 {"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},
                 {"include_mempool", RPCArg::Type::BOOL, /* default */ "true",
                  "Whether to include the mempool. Note that an unspent "
                  "output that is spent in the mempool won't appear."},
             },
             RPCResult{
                 "{\n"
                 "  \"bestblock\" : \"hash\",    (string) the block hash\n"
                 "  \"confirmations\" : n,       (numeric) The number of "
                 "confirmations\n"
                 "  \"value\" : x.xxx,           (numeric) The transaction "
                 "value in " +
                 CURRENCY_UNIT +
                 "\n"
                 "  \"scriptPubKey\" : {         (json object)\n"
                 "     \"asm\" : \"code\",       (string) \n"
                 "     \"hex\" : \"hex\",        (string) \n"
                 "     \"reqSigs\" : n,          (numeric) Number of required "
                 "signatures\n"
                 "     \"type\" : \"pubkeyhash\", (string) The type, eg "
                 "pubkeyhash\n"
                 "     \"addresses\" : [          (array of string) array of "
                 "bitcoin addresses\n"
                 "        \"address\"     (string) bitcoin address\n"
                 "        ,...\n"
                 "     ]\n"
                 "  },\n"
                 "  \"coinbase\" : true|false   (boolean) Coinbase or not\n"
                 "}\n"},
             RPCExamples{"\nGet unspent transactions\n" +
                         HelpExampleCli("listunspent", "") +
                         "\nView the details\n" +
                         HelpExampleCli("gettxout", "\"txid\" 1") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("gettxout", "\"txid\", 1")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     UniValue ret(UniValue::VOBJ);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
     int n = request.params[1].get_int();
     COutPoint out(txid, n);
     bool fMempool = true;
     if (!request.params[2].isNull()) {
         fMempool = request.params[2].get_bool();
     }
 
     Coin coin;
     if (fMempool) {
         LOCK(g_mempool.cs);
         CCoinsViewMemPool view(pcoinsTip.get(), g_mempool);
         if (!view.GetCoin(out, coin) || g_mempool.isSpent(out)) {
             return NullUniValue;
         }
     } else {
         if (!pcoinsTip->GetCoin(out, coin)) {
             return NullUniValue;
         }
     }
 
     const CBlockIndex *pindex = LookupBlockIndex(pcoinsTip->GetBestBlock());
     ret.pushKV("bestblock", pindex->GetBlockHash().GetHex());
     if (coin.GetHeight() == MEMPOOL_HEIGHT) {
         ret.pushKV("confirmations", 0);
     } else {
         ret.pushKV("confirmations",
                    int64_t(pindex->nHeight - coin.GetHeight() + 1));
     }
     ret.pushKV("value", ValueFromAmount(coin.GetTxOut().nValue));
     UniValue o(UniValue::VOBJ);
     ScriptPubKeyToUniv(coin.GetTxOut().scriptPubKey, o, true);
     ret.pushKV("scriptPubKey", o);
     ret.pushKV("coinbase", coin.IsCoinBase());
 
     return ret;
 }
 
 static UniValue verifychain(const Config &config,
                             const JSONRPCRequest &request) {
     int nCheckLevel = gArgs.GetArg("-checklevel", DEFAULT_CHECKLEVEL);
     int nCheckDepth = gArgs.GetArg("-checkblocks", DEFAULT_CHECKBLOCKS);
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "verifychain",
             "\nVerifies blockchain database.\n",
             {
                 {"checklevel", RPCArg::Type::NUM,
                  /* default */ strprintf("%d, range=0-4", nCheckLevel),
                  "How thorough the block verification is."},
                 {"nblocks", RPCArg::Type::NUM,
                  /* default */ strprintf("%d, 0=all", nCheckDepth),
                  "The number of blocks to check."},
             },
             RPCResult{"true|false       (boolean) Verified or not\n"},
             RPCExamples{HelpExampleCli("verifychain", "") +
                         HelpExampleRpc("verifychain", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     if (!request.params[0].isNull()) {
         nCheckLevel = request.params[0].get_int();
     }
     if (!request.params[1].isNull()) {
         nCheckDepth = request.params[1].get_int();
     }
 
     return CVerifyDB().VerifyDB(config, pcoinsTip.get(), nCheckLevel,
                                 nCheckDepth);
 }
 
 static void BIP9SoftForkDescPushBack(UniValue &softforks,
                                      const Consensus::Params &consensusParams,
                                      Consensus::DeploymentPos id)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     // For BIP9 deployments.
     // Deployments (e.g. testdummy) with timeout value before Jan 1, 2009 are
     // hidden. A timeout value of 0 guarantees a softfork will never be
     // activated. This is used when merging logic to implement a proposed
     // softfork without a specified deployment schedule.
     if (consensusParams.vDeployments[id].nTimeout <= 1230768000) {
         return;
     }
 
     UniValue bip9(UniValue::VOBJ);
     const ThresholdState thresholdState =
         VersionBitsTipState(consensusParams, id);
     switch (thresholdState) {
         case ThresholdState::DEFINED:
             bip9.pushKV("status", "defined");
             break;
         case ThresholdState::STARTED:
             bip9.pushKV("status", "started");
             break;
         case ThresholdState::LOCKED_IN:
             bip9.pushKV("status", "locked_in");
             break;
         case ThresholdState::ACTIVE:
             bip9.pushKV("status", "active");
             break;
         case ThresholdState::FAILED:
             bip9.pushKV("status", "failed");
             break;
     }
     if (ThresholdState::STARTED == thresholdState) {
         bip9.pushKV("bit", consensusParams.vDeployments[id].bit);
     }
     bip9.pushKV("start_time", consensusParams.vDeployments[id].nStartTime);
     bip9.pushKV("timeout", consensusParams.vDeployments[id].nTimeout);
     int64_t since_height = VersionBitsTipStateSinceHeight(consensusParams, id);
     bip9.pushKV("since", since_height);
     if (ThresholdState::STARTED == thresholdState) {
         UniValue statsUV(UniValue::VOBJ);
         BIP9Stats statsStruct = VersionBitsTipStatistics(consensusParams, id);
         statsUV.pushKV("period", statsStruct.period);
         statsUV.pushKV("threshold", statsStruct.threshold);
         statsUV.pushKV("elapsed", statsStruct.elapsed);
         statsUV.pushKV("count", statsStruct.count);
         statsUV.pushKV("possible", statsStruct.possible);
         bip9.pushKV("statistics", statsUV);
     }
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "bip9");
     rv.pushKV("bip9", bip9);
     if (ThresholdState::ACTIVE == thresholdState) {
         rv.pushKV("height", since_height);
     }
     rv.pushKV("active", ThresholdState::ACTIVE == thresholdState);
 
     softforks.pushKV(VersionBitsDeploymentInfo[id].name, rv);
 }
 
 UniValue getblockchaininfo(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getblockchaininfo",
             "Returns an object containing various state info "
             "regarding blockchain processing.\n",
             {},
             RPCResult{
                 "{\n"
                 "  \"chain\": \"xxxx\",              (string) current network "
                 "name as defined in BIP70 (main, test, regtest)\n"
                 "  \"blocks\": xxxxxx,             (numeric) the current "
                 "number of blocks processed in the server\n"
                 "  \"headers\": xxxxxx,            (numeric) the current "
                 "number of headers we have validated\n"
                 "  \"bestblockhash\": \"...\",       (string) the hash of the "
                 "currently best block\n"
                 "  \"difficulty\": xxxxxx,         (numeric) the current "
                 "difficulty\n"
                 "  \"mediantime\": xxxxxx,         (numeric) median time for "
                 "the current best block\n"
                 "  \"verificationprogress\": xxxx, (numeric) estimate of "
                 "verification progress [0..1]\n"
                 "  \"initialblockdownload\": xxxx, (bool) (debug information) "
                 "estimate of whether this node is in Initial Block Download "
                 "mode.\n"
                 "  \"chainwork\": \"xxxx\"           (string) total amount of "
                 "work in active chain, in hexadecimal\n"
                 "  \"size_on_disk\": xxxxxx,       (numeric) the estimated "
                 "size of the block and undo files on disk\n"
                 "  \"pruned\": xx,                 (boolean) if the blocks are "
                 "subject to pruning\n"
                 "  \"pruneheight\": xxxxxx,        (numeric) lowest-height "
                 "complete block stored (only present if pruning is enabled)\n"
                 "  \"automatic_pruning\": xx,      (boolean) whether automatic "
                 "pruning is enabled (only present if pruning is enabled)\n"
                 "  \"prune_target_size\": xxxxxx,  (numeric) the target size "
                 "used by pruning (only present if automatic pruning is "
                 "enabled)\n"
                 "  \"softforks\": {                (object) status of "
                 "softforks in progress\n"
                 "    \"xxxx\" : {                  (string) name of the "
                 "softfork\n"
                 "      \"type\" : \"bip9\",        (string) currently only set "
                 "to \"bip9\"\n"
                 "      \"bip9\" : {                (object) status of bip9 "
                 "softforks (only for \"bip9\" type)\n"
                 "        \"status\": \"xxxx\",     (string) one of "
                 "\"defined\", \"started\", \"locked_in\", \"active\", "
                 "\"failed\"\n"
                 "        \"bit\": xx,              (numeric) the bit (0-28) in "
                 "the block version field used to signal this softfork (only "
                 "for \"started\" status)\n"
                 "        \"startTime\": xx,        (numeric) the minimum "
                 "median time past of a block at which the bit gains its "
                 "meaning\n"
                 "        \"timeout\": xx,          (numeric) the median time "
                 "past of a block at which the deployment is considered failed "
                 "if not "
                 "yet locked in\n"
                 "        \"since\": xx,            (numeric) height of the "
                 "first block to which the status applies\n"
                 "        \"statistics\": {         (object) numeric statistics "
                 "about BIP9 signalling for a softfork (only for \"started\" "
                 "status)\n"
                 "          \"period\": xx,         (numeric) the length in "
                 "blocks of the BIP9 signalling period \n"
                 "          \"threshold\": xx,      (numeric) the number of "
                 "blocks with the version bit set required to activate the "
                 "feature \n"
                 "          \"elapsed\": xx,        (numeric) the number of "
                 "blocks elapsed since the beginning of the current period \n"
                 "          \"count\": xx,          (numeric) the number of "
                 "blocks with the version bit set in the current period \n"
                 "          \"possible\": xx        (boolean) returns false if "
                 "there are not enough blocks left in this period to pass "
                 "activation threshold\n"
                 "        },\n"
                 "        \"active\": xx,           (boolean) true if the rules "
                 "are enforced for the mempool and the next block\n"
                 "      }\n"
                 "    }\n"
                 "  }\n"
                 "  \"warnings\" : \"...\",           (string) any network and "
                 "blockchain warnings.\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("getblockchaininfo", "") +
                         HelpExampleRpc("getblockchaininfo", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     const CChainParams &chainparams = config.GetChainParams();
 
     const CBlockIndex *tip = ::ChainActive().Tip();
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("chain", chainparams.NetworkIDString());
     obj.pushKV("blocks", int(::ChainActive().Height()));
     obj.pushKV("headers", pindexBestHeader ? pindexBestHeader->nHeight : -1);
     obj.pushKV("bestblockhash", tip->GetBlockHash().GetHex());
     obj.pushKV("difficulty", double(GetDifficulty(tip)));
     obj.pushKV("mediantime", int64_t(tip->GetMedianTimePast()));
     obj.pushKV("verificationprogress",
                GuessVerificationProgress(Params().TxData(), tip));
     obj.pushKV("initialblockdownload",
                ::ChainstateActive().IsInitialBlockDownload());
     obj.pushKV("chainwork", tip->nChainWork.GetHex());
     obj.pushKV("size_on_disk", CalculateCurrentUsage());
     obj.pushKV("pruned", fPruneMode);
 
     if (fPruneMode) {
         const CBlockIndex *block = tip;
         assert(block);
         while (block->pprev && (block->pprev->nStatus.hasData())) {
             block = block->pprev;
         }
 
         obj.pushKV("pruneheight", block->nHeight);
 
         // if 0, execution bypasses the whole if block.
         bool automatic_pruning = (gArgs.GetArg("-prune", 0) != 1);
         obj.pushKV("automatic_pruning", automatic_pruning);
         if (automatic_pruning) {
             obj.pushKV("prune_target_size", nPruneTarget);
         }
     }
 
     UniValue softforks(UniValue::VOBJ);
     for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
         BIP9SoftForkDescPushBack(softforks, chainparams.GetConsensus(),
                                  Consensus::DeploymentPos(i));
     }
     obj.pushKV("softforks", softforks);
 
     obj.pushKV("warnings", GetWarnings("statusbar"));
     return obj;
 }
 
 /** Comparison function for sorting the getchaintips heads.  */
 struct CompareBlocksByHeight {
     bool operator()(const CBlockIndex *a, const CBlockIndex *b) const {
         // Make sure that unequal blocks with the same height do not compare
         // equal. Use the pointers themselves to make a distinction.
         if (a->nHeight != b->nHeight) {
             return (a->nHeight > b->nHeight);
         }
 
         return a < b;
     }
 };
 
 static UniValue getchaintips(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getchaintips",
             "Return information about all known tips in the block tree, "
             "including the main chain as well as orphaned branches.\n",
             {},
             RPCResult{
                 "[\n"
                 "  {\n"
                 "    \"height\": xxxx,         (numeric) height of the chain "
                 "tip\n"
                 "    \"hash\": \"xxxx\",         (string) block hash of the "
                 "tip\n"
                 "    \"branchlen\": 0          (numeric) zero for main chain\n"
                 "    \"status\": \"active\"      (string) \"active\" for the "
                 "main chain\n"
                 "  },\n"
                 "  {\n"
                 "    \"height\": xxxx,\n"
                 "    \"hash\": \"xxxx\",\n"
                 "    \"branchlen\": 1          (numeric) length of branch "
                 "connecting the tip to the main chain\n"
                 "    \"status\": \"xxxx\"        (string) status of the chain "
                 "(active, valid-fork, valid-headers, headers-only, invalid)\n"
                 "  }\n"
                 "]\n"
                 "Possible values for status:\n"
                 "1.  \"invalid\"               This branch contains at least "
                 "one invalid block\n"
                 "2.  \"parked\"                This branch contains at least "
                 "one parked block\n"
                 "3.  \"headers-only\"          Not all blocks for this branch "
                 "are available, but the headers are valid\n"
                 "4.  \"valid-headers\"         All blocks are available for "
                 "this branch, but they were never fully validated\n"
                 "5.  \"valid-fork\"            This branch is not part of the "
                 "active chain, but is fully validated\n"
                 "6.  \"active\"                This is the tip of the active "
                 "main chain, which is certainly valid\n"},
             RPCExamples{HelpExampleCli("getchaintips", "") +
                         HelpExampleRpc("getchaintips", "")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     /**
      * Idea:  the set of chain tips is ::ChainActive().tip, plus orphan blocks
      * which do not have another orphan building off of them. Algorithm:
      *  - Make one pass through mapBlockIndex, picking out the orphan blocks,
      * and also storing a set of the orphan block's pprev pointers.
      *  - Iterate through the orphan blocks. If the block isn't pointed to by
      * another orphan, it is a chain tip.
      *  - add ::ChainActive().Tip()
      */
     std::set<const CBlockIndex *, CompareBlocksByHeight> setTips;
     std::set<const CBlockIndex *> setOrphans;
     std::set<const CBlockIndex *> setPrevs;
 
     for (const std::pair<const BlockHash, CBlockIndex *> &item :
          mapBlockIndex) {
         if (!::ChainActive().Contains(item.second)) {
             setOrphans.insert(item.second);
             setPrevs.insert(item.second->pprev);
         }
     }
 
     for (std::set<const CBlockIndex *>::iterator it = setOrphans.begin();
          it != setOrphans.end(); ++it) {
         if (setPrevs.erase(*it) == 0) {
             setTips.insert(*it);
         }
     }
 
     // Always report the currently active tip.
     setTips.insert(::ChainActive().Tip());
 
     /* Construct the output array.  */
     UniValue res(UniValue::VARR);
     for (const CBlockIndex *block : setTips) {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("height", block->nHeight);
         obj.pushKV("hash", block->phashBlock->GetHex());
 
         const int branchLen =
             block->nHeight - ::ChainActive().FindFork(block)->nHeight;
         obj.pushKV("branchlen", branchLen);
 
         std::string status;
         if (::ChainActive().Contains(block)) {
             // This block is part of the currently active chain.
             status = "active";
         } else if (block->nStatus.isInvalid()) {
             // This block or one of its ancestors is invalid.
             status = "invalid";
         } else if (block->nStatus.isOnParkedChain()) {
             // This block or one of its ancestors is parked.
             status = "parked";
         } else if (!block->HaveTxsDownloaded()) {
             // This block cannot be connected because full block data for it or
             // one of its parents is missing.
             status = "headers-only";
         } else if (block->IsValid(BlockValidity::SCRIPTS)) {
             // This block is fully validated, but no longer part of the active
             // chain. It was probably the active block once, but was
             // reorganized.
             status = "valid-fork";
         } else if (block->IsValid(BlockValidity::TREE)) {
             // The headers for this block are valid, but it has not been
             // validated. It was probably never part of the most-work chain.
             status = "valid-headers";
         } else {
             // No clue.
             status = "unknown";
         }
         obj.pushKV("status", status);
 
         res.push_back(obj);
     }
 
     return res;
 }
 
 UniValue MempoolInfoToJSON(const CTxMemPool &pool) {
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("loaded", pool.IsLoaded());
     ret.pushKV("size", (int64_t)pool.size());
     ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
     ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
     size_t maxmempool =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     ret.pushKV("maxmempool", (int64_t)maxmempool);
     ret.pushKV(
         "mempoolminfee",
         ValueFromAmount(std::max(pool.GetMinFee(maxmempool), ::minRelayTxFee)
                             .GetFeePerK()));
     ret.pushKV("minrelaytxfee", ValueFromAmount(::minRelayTxFee.GetFeePerK()));
 
     return ret;
 }
 
 static UniValue getmempoolinfo(const Config &config,
                                const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getmempoolinfo",
             "\nReturns details on the active state of the TX memory "
             "pool.\n",
             {},
             RPCResult{
                 "{\n"
                 "  \"loaded\": true|false         (boolean) True if the "
                 "mempool is fully loaded\n"
                 "  \"size\": xxxxx,               (numeric) Current tx count\n"
                 "  \"bytes\": xxxxx,              (numeric) Transaction size.\n"
                 "  \"usage\": xxxxx,              (numeric) Total memory usage "
                 "for the mempool\n"
                 "  \"maxmempool\": xxxxx,         (numeric) Maximum memory "
                 "usage for the mempool\n"
                 "  \"mempoolminfee\": xxxxx       (numeric) Minimum fee rate "
                 "in " +
                 CURRENCY_UNIT +
                 "/kB for tx to be accepted. Is the maximum of minrelaytxfee "
                 "and minimum mempool fee\n"
                 "  \"minrelaytxfee\": xxxxx       (numeric) Current minimum "
                 "relay fee for transactions\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("getmempoolinfo", "") +
                         HelpExampleRpc("getmempoolinfo", "")},
         }
                                      .ToString());
     }
 
     return MempoolInfoToJSON(::g_mempool);
 }
 
 static UniValue preciousblock(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "preciousblock",
             "\nTreats a block as if it were received before others "
             "with the same work.\n"
             "\nA later preciousblock call can override the effect "
             "of an earlier one.\n"
             "\nThe effects of preciousblock are not retained across "
             "restarts.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to mark as precious"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("preciousblock", "\"blockhash\"") +
                         HelpExampleRpc("preciousblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
     CBlockIndex *pblockindex;
 
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
 
     CValidationState state;
     PreciousBlock(config, state, pblockindex);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 UniValue finalizeblock(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "finalizeblock",
             "\nTreats a block as final. It cannot be reorged. Any chain\n"
             "that does not contain this block is invalid. Used on a less\n"
             "work chain, it can effectively PUTS YOU OUT OF CONSENSUS.\n"
             "USE WITH CAUTION!\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to mark as invalid"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("invalidateblock", "\"blockhash\"") +
                         HelpExampleRpc("invalidateblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     std::string strHash = request.params[0].get_str();
     BlockHash hash(uint256S(strHash));
     CValidationState state;
 
     {
         LOCK(cs_main);
         CBlockIndex *pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         FinalizeBlockAndInvalidate(config, state, pblockindex);
     }
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, FormatStateMessage(state));
     }
 
     return NullUniValue;
 }
 
 static UniValue invalidateblock(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "invalidateblock",
             "\nPermanently marks a block as invalid, as if it "
             "violated a consensus rule.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to mark as invalid"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("invalidateblock", "\"blockhash\"") +
                         HelpExampleRpc("invalidateblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
     CValidationState state;
 
     CBlockIndex *pblockindex;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
     InvalidateBlock(config, state, pblockindex);
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, FormatStateMessage(state));
     }
 
     return NullUniValue;
 }
 
 UniValue parkblock(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "parkblock",
             "\nMarks a block as parked.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to park"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("parkblock", "\"blockhash\"") +
                         HelpExampleRpc("parkblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     const std::string strHash = request.params[0].get_str();
     const BlockHash hash(uint256S(strHash));
     CValidationState state;
 
     CBlockIndex *pblockindex;
     {
         LOCK(cs_main);
         if (mapBlockIndex.count(hash) == 0) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         pblockindex = mapBlockIndex[hash];
     }
     ParkBlock(config, state, pblockindex);
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 static UniValue reconsiderblock(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "reconsiderblock",
             "\nRemoves invalidity status of a block and its descendants, "
             "reconsider them for activation.\n"
             "This can be used to undo the effects of invalidateblock.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to reconsider"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("reconsiderblock", "\"blockhash\"") +
                         HelpExampleRpc("reconsiderblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     {
         LOCK(cs_main);
         CBlockIndex *pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         ResetBlockFailureFlags(pblockindex);
     }
 
     CValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, FormatStateMessage(state));
     }
 
     return NullUniValue;
 }
 
 UniValue unparkblock(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "unparkblock",
             "\nRemoves parked status of a block and its descendants, "
             "reconsider them for activation.\n"
             "This can be used to undo the effects of parkblock.\n",
             {
                 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hash of the block to unpark"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("unparkblock", "\"blockhash\"") +
                         HelpExampleRpc("unparkblock", "\"blockhash\"")},
         }
                                      .ToString());
     }
 
     const std::string strHash = request.params[0].get_str();
     const BlockHash hash(uint256S(strHash));
 
     {
         LOCK(cs_main);
         if (mapBlockIndex.count(hash) == 0) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         CBlockIndex *pblockindex = mapBlockIndex[hash];
         UnparkBlockAndChildren(pblockindex);
     }
 
     CValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 static UniValue getchaintxstats(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getchaintxstats",
             "\nCompute statistics about the total number and rate "
             "of transactions in the chain.\n",
             {
                 {"nblocks", RPCArg::Type::NUM, /* default */ "one month",
                  "Size of the window in number of blocks"},
                 {"blockhash", RPCArg::Type::STR_HEX, /* default */ "chain tip",
                  "The hash of the block that ends the window."},
             },
             RPCResult{
                 "{\n"
                 "  \"time\": xxxxx,                         (numeric) The "
                 "timestamp for the final block in the window in UNIX format.\n"
                 "  \"txcount\": xxxxx,                      (numeric) The "
                 "total number of transactions in the chain up to that point.\n"
                 "  \"window_final_block_hash\": \"...\",      (string) The "
                 "hash of the final block in the window.\n"
                 "  \"window_block_count\": xxxxx,           (numeric) Size of "
                 "the window in number of blocks.\n"
                 "  \"window_tx_count\": xxxxx,              (numeric) The "
                 "number of transactions in the window. Only returned if "
                 "\"window_block_count\" is > 0.\n"
                 "  \"window_interval\": xxxxx,              (numeric) The "
                 "elapsed time in the window in seconds. Only returned if "
                 "\"window_block_count\" is > 0.\n"
                 "  \"txrate\": x.xx,                        (numeric) The "
                 "average rate of transactions per second in the window. Only "
                 "returned if \"window_interval\" is > 0.\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("getchaintxstats", "") +
                         HelpExampleRpc("getchaintxstats", "2016")},
         }
                                      .ToString());
     }
 
     const CBlockIndex *pindex;
 
     // By default: 1 month
     int blockcount = 30 * 24 * 60 * 60 /
                      config.GetChainParams().GetConsensus().nPowTargetSpacing;
 
     if (request.params[1].isNull()) {
         LOCK(cs_main);
         pindex = ::ChainActive().Tip();
     } else {
         BlockHash hash(ParseHashV(request.params[1], "blockhash"));
         LOCK(cs_main);
         pindex = LookupBlockIndex(hash);
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
         if (!::ChainActive().Contains(pindex)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Block is not in main chain");
         }
     }
 
     assert(pindex != nullptr);
 
     if (request.params[0].isNull()) {
         blockcount = std::max(0, std::min(blockcount, pindex->nHeight - 1));
     } else {
         blockcount = request.params[0].get_int();
 
         if (blockcount < 0 ||
             (blockcount > 0 && blockcount >= pindex->nHeight)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid block count: "
                                                       "should be between 0 and "
                                                       "the block's height - 1");
         }
     }
 
     const CBlockIndex *pindexPast =
         pindex->GetAncestor(pindex->nHeight - blockcount);
     int nTimeDiff =
         pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
     int nTxDiff = pindex->GetChainTxCount() - pindexPast->GetChainTxCount();
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("time", pindex->GetBlockTime());
     ret.pushKV("txcount", pindex->GetChainTxCount());
     ret.pushKV("window_final_block_hash", pindex->GetBlockHash().GetHex());
     ret.pushKV("window_block_count", blockcount);
     if (blockcount > 0) {
         ret.pushKV("window_tx_count", nTxDiff);
         ret.pushKV("window_interval", nTimeDiff);
         if (nTimeDiff > 0) {
             ret.pushKV("txrate", double(nTxDiff) / nTimeDiff);
         }
     }
 
     return ret;
 }
 
 template <typename T>
 static T CalculateTruncatedMedian(std::vector<T> &scores) {
     size_t size = scores.size();
     if (size == 0) {
         return T();
     }
 
     std::sort(scores.begin(), scores.end());
     if (size % 2 == 0) {
         return (scores[size / 2 - 1] + scores[size / 2]) / 2;
     } else {
         return scores[size / 2];
     }
 }
 
 template <typename T> static inline bool SetHasKeys(const std::set<T> &set) {
     return false;
 }
 template <typename T, typename Tk, typename... Args>
 static inline bool SetHasKeys(const std::set<T> &set, const Tk &key,
                               const Args &... args) {
     return (set.count(key) != 0) || SetHasKeys(set, args...);
 }
 
 // outpoint (needed for the utxo index) + nHeight + fCoinBase
 static constexpr size_t PER_UTXO_OVERHEAD =
     sizeof(COutPoint) + sizeof(uint32_t) + sizeof(bool);
 
 static UniValue getblockstats(const Config &config,
                               const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "getblockstats",
         "\nCompute per block statistics for a given window. All amounts are "
         "in " +
             CURRENCY_UNIT +
             ".\n"
-            "It won't work for some heights with pruning.\n"
-            "It won't work without -txindex for utxo_size_inc, *fee or "
-            "*feerate stats.\n",
+            "It won't work for some heights with pruning.\n",
         {
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::NO,
              "The block hash or height of the target block",
              "",
              {"", "string or numeric"}},
             {"stats",
              RPCArg::Type::ARR,
              /* default */ "all values",
              "Values to plot (see result below)",
              {
                  {"height", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
                  {"time", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
              },
              "stats"},
         },
         RPCResult{
             "{                           (json object)\n"
             "  \"avgfee\": x.xxx,          (numeric) Average fee in the block\n"
             "  \"avgfeerate\": x.xxx,      (numeric) Average feerate (in " +
             CURRENCY_UNIT +
             " per byte)\n"
             "  \"avgtxsize\": xxxxx,       (numeric) Average transaction size\n"
             "  \"blockhash\": xxxxx,       (string) The block hash (to check "
             "for potential reorgs)\n"
             "  \"height\": xxxxx,          (numeric) The height of the block\n"
             "  \"ins\": xxxxx,             (numeric) The number of inputs "
             "(excluding coinbase)\n"
             "  \"maxfee\": xxxxx,          (numeric) Maximum fee in the block\n"
             "  \"maxfeerate\": xxxxx,      (numeric) Maximum feerate (in " +
             CURRENCY_UNIT +
             " per byte)\n"
             "  \"maxtxsize\": xxxxx,       (numeric) Maximum transaction size\n"
             "  \"medianfee\": x.xxx,       (numeric) Truncated median fee in "
             "the block\n"
             "  \"medianfeerate\": x.xxx,   (numeric) Truncated median feerate "
             "(in " +
             CURRENCY_UNIT +
             " per byte)\n"
             "  \"mediantime\": xxxxx,      (numeric) The block median time "
             "past\n"
             "  \"mediantxsize\": xxxxx,    (numeric) Truncated median "
             "transaction size\n"
             "  \"minfee\": x.xxx,          (numeric) Minimum fee in the block\n"
             "  \"minfeerate\": xx.xx,      (numeric) Minimum feerate (in " +
             CURRENCY_UNIT +
             " per byte)\n"
             "  \"mintxsize\": xxxxx,       (numeric) Minimum transaction size\n"
             "  \"outs\": xxxxx,            (numeric) The number of outputs\n"
             "  \"subsidy\": x.xxx,         (numeric) The block subsidy\n"
             "  \"time\": xxxxx,            (numeric) The block time\n"
             "  \"total_out\": x.xxx,       (numeric) Total amount in all "
             "outputs (excluding coinbase and thus reward [ie subsidy + "
             "totalfee])\n"
             "  \"total_size\": xxxxx,      (numeric) Total size of all "
             "non-coinbase transactions\n"
             "  \"totalfee\": x.xxx,        (numeric) The fee total\n"
             "  \"txs\": xxxxx,             (numeric) The number of "
             "transactions (excluding coinbase)\n"
             "  \"utxo_increase\": xxxxx,   (numeric) The increase/decrease in "
             "the number of unspent outputs\n"
             "  \"utxo_size_inc\": xxxxx,   (numeric) The increase/decrease in "
             "size for the utxo index (not discounting op_return and similar)\n"
             "}\n"},
         RPCExamples{HelpExampleCli("getblockstats",
                                    "1000 '[\"minfeerate\",\"avgfeerate\"]'") +
                     HelpExampleRpc("getblockstats",
                                    "1000 '[\"minfeerate\",\"avgfeerate\"]'")},
     };
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size())) {
         throw std::runtime_error(help.ToString());
     }
 
     LOCK(cs_main);
 
     CBlockIndex *pindex;
     if (request.params[0].isNum()) {
         const int height = request.params[0].get_int();
         const int current_tip = ::ChainActive().Height();
         if (height < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d is negative", height));
         }
         if (height > current_tip) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d after current tip %d", height,
                           current_tip));
         }
 
         pindex = ::ChainActive()[height];
     } else {
         const BlockHash hash(ParseHashV(request.params[0], "hash_or_height"));
         pindex = LookupBlockIndex(hash);
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
         if (!::ChainActive().Contains(pindex)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                strprintf("Block is not in chain %s",
                                          Params().NetworkIDString()));
         }
     }
 
     assert(pindex != nullptr);
 
     std::set<std::string> stats;
     if (!request.params[1].isNull()) {
         const UniValue stats_univalue = request.params[1].get_array();
         for (unsigned int i = 0; i < stats_univalue.size(); i++) {
             const std::string stat = stats_univalue[i].get_str();
             stats.insert(stat);
         }
     }
 
     const CBlock block = GetBlockChecked(config, pindex);
+    const CBlockUndo blockUndo = GetUndoChecked(pindex);
 
     // Calculate everything if nothing selected (default)
     const bool do_all = stats.size() == 0;
     const bool do_mediantxsize = do_all || stats.count("mediantxsize") != 0;
     const bool do_medianfee = do_all || stats.count("medianfee") != 0;
     const bool do_medianfeerate = do_all || stats.count("medianfeerate") != 0;
     const bool loop_inputs =
         do_all || do_medianfee || do_medianfeerate ||
         SetHasKeys(stats, "utxo_size_inc", "totalfee", "avgfee", "avgfeerate",
                    "minfee", "maxfee", "minfeerate", "maxfeerate");
     const bool loop_outputs = do_all || loop_inputs || stats.count("total_out");
     const bool do_calculate_size =
         do_mediantxsize || loop_inputs ||
         SetHasKeys(stats, "total_size", "avgtxsize", "mintxsize", "maxtxsize");
 
-    if (loop_inputs && !g_txindex) {
-        throw JSONRPCError(
-            RPC_INVALID_PARAMETER,
-            "One or more of the selected stats requires -txindex enabled");
-    }
-
     const int64_t blockMaxSize = config.GetMaxBlockSize();
     Amount maxfee = Amount::zero();
     Amount maxfeerate = Amount::zero();
     Amount minfee = MAX_MONEY;
     Amount minfeerate = MAX_MONEY;
     Amount total_out = Amount::zero();
     Amount totalfee = Amount::zero();
     int64_t inputs = 0;
     int64_t maxtxsize = 0;
     int64_t mintxsize = blockMaxSize;
     int64_t outputs = 0;
     int64_t total_size = 0;
     int64_t utxo_size_inc = 0;
     std::vector<Amount> fee_array;
     std::vector<Amount> feerate_array;
     std::vector<int64_t> txsize_array;
 
-    const Consensus::Params &params = config.GetChainParams().GetConsensus();
-
-    for (const auto &tx : block.vtx) {
+    for (size_t i = 0; i < block.vtx.size(); ++i) {
+        const auto &tx = block.vtx.at(i);
         outputs += tx->vout.size();
         Amount tx_total_out = Amount::zero();
         if (loop_outputs) {
             for (const CTxOut &out : tx->vout) {
                 tx_total_out += out.nValue;
                 utxo_size_inc +=
                     GetSerializeSize(out, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
             }
         }
 
         if (tx->IsCoinBase()) {
             continue;
         }
 
         // Don't count coinbase's fake input
         inputs += tx->vin.size();
         // Don't count coinbase reward
         total_out += tx_total_out;
 
         int64_t tx_size = 0;
         if (do_calculate_size) {
             tx_size = tx->GetTotalSize();
             if (do_mediantxsize) {
                 txsize_array.push_back(tx_size);
             }
             maxtxsize = std::max(maxtxsize, tx_size);
             mintxsize = std::min(mintxsize, tx_size);
             total_size += tx_size;
         }
 
         if (loop_inputs) {
             Amount tx_total_in = Amount::zero();
-            for (const CTxIn &in : tx->vin) {
-                CTransactionRef tx_in;
-                BlockHash hashBlock;
-                if (!GetTransaction(in.prevout.GetTxId(), tx_in, params,
-                                    hashBlock)) {
-                    throw JSONRPCError(RPC_INTERNAL_ERROR,
-                                       std::string("Unexpected internal error "
-                                                   "(tx index seems corrupt)"));
-                }
-
-                CTxOut prevoutput = tx_in->vout[in.prevout.GetN()];
+            const auto &txundo = blockUndo.vtxundo.at(i - 1);
+            for (const Coin &coin : txundo.vprevout) {
+                const CTxOut &prevoutput = coin.GetTxOut();
 
                 tx_total_in += prevoutput.nValue;
                 utxo_size_inc -=
                     GetSerializeSize(prevoutput, PROTOCOL_VERSION) +
                     PER_UTXO_OVERHEAD;
             }
 
             Amount txfee = tx_total_in - tx_total_out;
             assert(MoneyRange(txfee));
             if (do_medianfee) {
                 fee_array.push_back(txfee);
             }
             maxfee = std::max(maxfee, txfee);
             minfee = std::min(minfee, txfee);
             totalfee += txfee;
 
             Amount feerate = txfee / tx_size;
             if (do_medianfeerate) {
                 feerate_array.push_back(feerate);
             }
             maxfeerate = std::max(maxfeerate, feerate);
             minfeerate = std::min(minfeerate, feerate);
         }
     }
 
     UniValue ret_all(UniValue::VOBJ);
     ret_all.pushKV("avgfee",
                    ValueFromAmount((block.vtx.size() > 1)
                                        ? totalfee / int((block.vtx.size() - 1))
                                        : Amount::zero()));
     ret_all.pushKV("avgfeerate",
                    ValueFromAmount((total_size > 0) ? totalfee / total_size
                                                     : Amount::zero()));
     ret_all.pushKV("avgtxsize", (block.vtx.size() > 1)
                                     ? total_size / (block.vtx.size() - 1)
                                     : 0);
     ret_all.pushKV("blockhash", pindex->GetBlockHash().GetHex());
     ret_all.pushKV("height", (int64_t)pindex->nHeight);
     ret_all.pushKV("ins", inputs);
     ret_all.pushKV("maxfee", ValueFromAmount(maxfee));
     ret_all.pushKV("maxfeerate", ValueFromAmount(maxfeerate));
     ret_all.pushKV("maxtxsize", maxtxsize);
     ret_all.pushKV("medianfee",
                    ValueFromAmount(CalculateTruncatedMedian(fee_array)));
     ret_all.pushKV("medianfeerate",
                    ValueFromAmount(CalculateTruncatedMedian(feerate_array)));
     ret_all.pushKV("mediantime", pindex->GetMedianTimePast());
     ret_all.pushKV("mediantxsize", CalculateTruncatedMedian(txsize_array));
     ret_all.pushKV(
         "minfee",
         ValueFromAmount((minfee == MAX_MONEY) ? Amount::zero() : minfee));
     ret_all.pushKV("minfeerate",
                    ValueFromAmount((minfeerate == MAX_MONEY) ? Amount::zero()
                                                              : minfeerate));
     ret_all.pushKV("mintxsize", mintxsize == blockMaxSize ? 0 : mintxsize);
     ret_all.pushKV("outs", outputs);
     ret_all.pushKV("subsidy", ValueFromAmount(GetBlockSubsidy(
                                   pindex->nHeight, Params().GetConsensus())));
     ret_all.pushKV("time", pindex->GetBlockTime());
     ret_all.pushKV("total_out", ValueFromAmount(total_out));
     ret_all.pushKV("total_size", total_size);
     ret_all.pushKV("totalfee", ValueFromAmount(totalfee));
     ret_all.pushKV("txs", (int64_t)block.vtx.size());
     ret_all.pushKV("utxo_increase", outputs - inputs);
     ret_all.pushKV("utxo_size_inc", utxo_size_inc);
 
     if (do_all) {
         return ret_all;
     }
 
     UniValue ret(UniValue::VOBJ);
     for (const std::string &stat : stats) {
         const UniValue &value = ret_all[stat];
         if (value.isNull()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid selected statistic %s", stat));
         }
         ret.pushKV(stat, value);
     }
     return ret;
 }
 
 static UniValue savemempool(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "savemempool",
             "\nDumps the mempool to disk. It will fail until the "
             "previous dump is fully loaded.\n",
             {},
             RPCResults{},
             RPCExamples{HelpExampleCli("savemempool", "") +
                         HelpExampleRpc("savemempool", "")},
         }
                                      .ToString());
     }
 
     if (!::g_mempool.IsLoaded()) {
         throw JSONRPCError(RPC_MISC_ERROR, "The mempool was not loaded yet");
     }
 
     if (!DumpMempool(::g_mempool)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Unable to dump mempool to disk");
     }
 
     return NullUniValue;
 }
 
 //! Search for a given set of pubkey scripts
 static bool FindScriptPubKey(std::atomic<int> &scan_progress,
                              const std::atomic<bool> &should_abort,
                              int64_t &count, CCoinsViewCursor *cursor,
                              const std::set<CScript> &needles,
                              std::map<COutPoint, Coin> &out_results) {
     scan_progress = 0;
     count = 0;
     while (cursor->Valid()) {
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) {
             return false;
         }
         if (++count % 8192 == 0) {
             boost::this_thread::interruption_point();
             if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
         }
         if (count % 256 == 0) {
             // update progress reference every 256 item
             const TxId &txid = key.GetTxId();
             uint32_t high = 0x100 * *txid.begin() + *(txid.begin() + 1);
             scan_progress = int(high * 100.0 / 65536.0 + 0.5);
         }
         if (needles.count(coin.GetTxOut().scriptPubKey)) {
             out_results.emplace(key, coin);
         }
         cursor->Next();
     }
     scan_progress = 100;
     return true;
 }
 
 /** RAII object to prevent concurrency issue when scanning the txout set */
 static std::mutex g_utxosetscan;
 static std::atomic<int> g_scan_progress;
 static std::atomic<bool> g_scan_in_progress;
 static std::atomic<bool> g_should_abort_scan;
 class CoinsViewScanReserver {
 private:
     bool m_could_reserve;
 
 public:
     explicit CoinsViewScanReserver() : m_could_reserve(false) {}
 
     bool reserve() {
         assert(!m_could_reserve);
         std::lock_guard<std::mutex> lock(g_utxosetscan);
         if (g_scan_in_progress) {
             return false;
         }
         g_scan_in_progress = true;
         m_could_reserve = true;
         return true;
     }
 
     ~CoinsViewScanReserver() {
         if (m_could_reserve) {
             std::lock_guard<std::mutex> lock(g_utxosetscan);
             g_scan_in_progress = false;
         }
     }
 };
 
 static UniValue scantxoutset(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "scantxoutset",
             "\nEXPERIMENTAL warning: this call may be removed or changed "
             "in future releases.\n"
             "\nScans the unspent transaction output set for entries that "
             "match certain output descriptors.\n"
             "Examples of output descriptors are:\n"
             "    addr(<address>)                      Outputs whose "
             "scriptPubKey corresponds to the specified address (does not "
             "include P2PK)\n"
             "    raw(<hex script>)                    Outputs whose "
             "scriptPubKey equals the specified hex scripts\n"
             "    combo(<pubkey>)                      P2PK and P2PKH "
             "outputs for the given pubkey\n"
             "    pkh(<pubkey>)                        P2PKH outputs for "
             "the given pubkey\n"
             "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig "
             "outputs for the given threshold and pubkeys\n"
             "\nIn the above, <pubkey> either refers to a fixed public key "
             "in hexadecimal notation, or to an xpub/xprv optionally "
             "followed by one\n"
             "or more path elements separated by \"/\", and optionally "
             "ending in \"/*\" (unhardened), or \"/*'\" or \"/*h\" "
             "(hardened) to specify all\n"
             "unhardened or hardened child keys.\n"
             "In the latter case, a range needs to be specified by below if "
             "different from 1000.\n"
             "For more information on output descriptors, see the "
             "documentation in the doc/descriptors.md file.\n",
             {
                 {"action", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The action to execute\n"
                  "                                      \"start\" for "
                  "starting a scan\n"
                  "                                      \"abort\" for "
                  "aborting the current scan (returns true when abort was "
                  "successful)\n"
                  "                                      \"status\" for "
                  "progress report (in %) of the current scan"},
                 {"scanobjects",
                  RPCArg::Type::ARR,
                  RPCArg::Optional::NO,
                  "Array of scan objects\n"
                  "                                  Every scan object is "
                  "either a string descriptor or an object:",
                  {
                      {"descriptor", RPCArg::Type::STR,
                       RPCArg::Optional::OMITTED, "An output descriptor"},
                      {
                          "",
                          RPCArg::Type::OBJ,
                          RPCArg::Optional::OMITTED,
                          "An object with output descriptor and metadata",
                          {
                              {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                               "An output descriptor"},
                              {"range", RPCArg::Type::NUM, /* default */ "1000",
                               "Up to what child index HD chains should be "
                               "explored"},
                          },
                      },
                  },
                  "[scanobjects,...]"},
             },
             RPCResult{
                 "{\n"
                 "  \"unspents\": [\n"
                 "    {\n"
                 "    \"txid\" : \"transactionid\",     (string) The "
                 "transaction id\n"
                 "    \"vout\": n,                    (numeric) the vout value\n"
                 "    \"scriptPubKey\" : \"script\",    (string) the script "
                 "key\n"
                 "    \"desc\" : \"descriptor\",        (string) A specialized "
                 "descriptor for the matched scriptPubKey\n"
                 "    \"amount\" : x.xxx,             (numeric) The total "
                 "amount in " +
                 CURRENCY_UNIT +
                 " of the unspent output\n"
                 "    \"height\" : n,                 (numeric) Height of the "
                 "unspent transaction output\n"
                 "   }\n"
                 "   ,...], \n"
                 " \"total_amount\" : x.xxx,          (numeric) The total "
                 "amount of all found unspent outputs in " +
                 CURRENCY_UNIT +
                 "\n"
                 "]\n"},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR});
 
     UniValue result(UniValue::VOBJ);
     if (request.params[0].get_str() == "status") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // no scan in progress
             return NullUniValue;
         }
         result.pushKV("progress", g_scan_progress.load());
         return result;
     } else if (request.params[0].get_str() == "abort") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // reserve was possible which means no scan was running
             return false;
         }
         // set the abort flag
         g_should_abort_scan = true;
         return true;
     } else if (request.params[0].get_str() == "start") {
         CoinsViewScanReserver reserver;
         if (!reserver.reserve()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Scan already in progress, use action \"abort\" or \"status\"");
         }
         std::set<CScript> needles;
         std::map<CScript, std::string> descriptors;
         Amount total_in = Amount::zero();
 
         // loop through the scan objects
         for (const UniValue &scanobject :
              request.params[1].get_array().getValues()) {
             std::string desc_str;
             int range = 1000;
             if (scanobject.isStr()) {
                 desc_str = scanobject.get_str();
             } else if (scanobject.isObject()) {
                 UniValue desc_uni = find_value(scanobject, "desc");
                 if (desc_uni.isNull()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Descriptor needs to be provided in scan object");
                 }
                 desc_str = desc_uni.get_str();
                 UniValue range_uni = find_value(scanobject, "range");
                 if (!range_uni.isNull()) {
                     range = range_uni.get_int();
                     if (range < 0 || range > 1000000) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "range out of range");
                     }
                 }
             } else {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Scan object needs to be either a string or an object");
             }
 
             FlatSigningProvider provider;
             auto desc = Parse(desc_str, provider);
             if (!desc) {
                 throw JSONRPCError(
                     RPC_INVALID_ADDRESS_OR_KEY,
                     strprintf("Invalid descriptor '%s'", desc_str));
             }
             if (!desc->IsRange()) {
                 range = 0;
             }
             for (int i = 0; i <= range; ++i) {
                 std::vector<CScript> scripts;
                 if (!desc->Expand(i, provider, scripts, provider)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         strprintf(
                             "Cannot derive script without private keys: '%s'",
                             desc_str));
                 }
                 for (const auto &script : scripts) {
                     std::string inferred =
                         InferDescriptor(script, provider)->ToString();
                     needles.emplace(script);
                     descriptors.emplace(std::move(script), std::move(inferred));
                 }
             }
         }
 
         // Scan the unspent transaction output set for inputs
         UniValue unspents(UniValue::VARR);
         std::vector<CTxOut> input_txos;
         std::map<COutPoint, Coin> coins;
         g_should_abort_scan = false;
         g_scan_progress = 0;
         int64_t count = 0;
         std::unique_ptr<CCoinsViewCursor> pcursor;
         {
             LOCK(cs_main);
             ::ChainstateActive().ForceFlushStateToDisk();
             pcursor = std::unique_ptr<CCoinsViewCursor>(pcoinsdbview->Cursor());
             assert(pcursor);
         }
         bool res = FindScriptPubKey(g_scan_progress, g_should_abort_scan, count,
                                     pcursor.get(), needles, coins);
         result.pushKV("success", res);
         result.pushKV("searched_items", count);
 
         for (const auto &it : coins) {
             const COutPoint &outpoint = it.first;
             const Coin &coin = it.second;
             const CTxOut &txo = coin.GetTxOut();
             input_txos.push_back(txo);
             total_in += txo.nValue;
 
             UniValue unspent(UniValue::VOBJ);
             unspent.pushKV("txid", outpoint.GetTxId().GetHex());
             unspent.pushKV("vout", int32_t(outpoint.GetN()));
             unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey.begin(),
                                                   txo.scriptPubKey.end()));
             unspent.pushKV("desc", descriptors[txo.scriptPubKey]);
             unspent.pushKV("amount", ValueFromAmount(txo.nValue));
             unspent.pushKV("height", int32_t(coin.GetHeight()));
 
             unspents.push_back(unspent);
         }
         result.pushKV("unspents", unspents);
         result.pushKV("total_amount", ValueFromAmount(total_in));
     } else {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid command");
     }
     return result;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                      actor (function)        argNames
     //  ------------------- ------------------------  ----------------------  ----------
     { "blockchain",         "getbestblockhash",       getbestblockhash,       {} },
     { "blockchain",         "getblock",               getblock,               {"blockhash","verbosity|verbose"} },
     { "blockchain",         "getblockchaininfo",      getblockchaininfo,      {} },
     { "blockchain",         "getblockcount",          getblockcount,          {} },
     { "blockchain",         "getblockhash",           getblockhash,           {"height"} },
     { "blockchain",         "getblockheader",         getblockheader,         {"blockhash","verbose"} },
     { "blockchain",         "getblockstats",          getblockstats,          {"hash_or_height","stats"} },
     { "blockchain",         "getchaintips",           getchaintips,           {} },
     { "blockchain",         "getchaintxstats",        getchaintxstats,        {"nblocks", "blockhash"} },
     { "blockchain",         "getdifficulty",          getdifficulty,          {} },
     { "blockchain",         "getmempoolancestors",    getmempoolancestors,    {"txid","verbose"} },
     { "blockchain",         "getmempooldescendants",  getmempooldescendants,  {"txid","verbose"} },
     { "blockchain",         "getmempoolentry",        getmempoolentry,        {"txid"} },
     { "blockchain",         "getmempoolinfo",         getmempoolinfo,         {} },
     { "blockchain",         "getrawmempool",          getrawmempool,          {"verbose"} },
     { "blockchain",         "gettxout",               gettxout,               {"txid","n","include_mempool"} },
     { "blockchain",         "gettxoutsetinfo",        gettxoutsetinfo,        {} },
     { "blockchain",         "pruneblockchain",        pruneblockchain,        {"height"} },
     { "blockchain",         "savemempool",            savemempool,            {} },
     { "blockchain",         "verifychain",            verifychain,            {"checklevel","nblocks"} },
     { "blockchain",         "preciousblock",          preciousblock,          {"blockhash"} },
     { "blockchain",         "scantxoutset",           scantxoutset,           {"action", "scanobjects"} },
 
     /* Not shown in help */
     { "hidden",             "getfinalizedblockhash",            getfinalizedblockhash,            {} },
     { "hidden",             "finalizeblock",                    finalizeblock,                    {"blockhash"} },
     { "hidden",             "invalidateblock",                  invalidateblock,                  {"blockhash"} },
     { "hidden",             "parkblock",                        parkblock,                        {"blockhash"} },
     { "hidden",             "reconsiderblock",                  reconsiderblock,                  {"blockhash"} },
     { "hidden",             "syncwithvalidationinterfacequeue", syncwithvalidationinterfacequeue, {} },
     { "hidden",             "unparkblock",                      unparkblock,                      {"blockhash"} },
     { "hidden",             "waitfornewblock",                  waitfornewblock,                  {"timeout"} },
     { "hidden",             "waitforblock",                     waitforblock,                     {"blockhash","timeout"} },
     { "hidden",             "waitforblockheight",               waitforblockheight,               {"height","timeout"} },
 };
 // clang-format on
 
 void RegisterBlockchainRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/test/functional/data/rpc_getblockstats.json b/test/functional/data/rpc_getblockstats.json
index 1e8aa69f7..c665a5e1c 100644
--- a/test/functional/data/rpc_getblockstats.json
+++ b/test/functional/data/rpc_getblockstats.json
@@ -1,192 +1,192 @@
 {
   "blocks": [
     "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000",
-    "0000002006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f603cceb3f73a7cb716e4302f895f710a6b2009fef95644e20bb63d48f5036c95fcae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c510101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a1b229d0834168737317fe9ff3f0efe41d0c1cf497610fa249f8f75fd3546a43ab6fdeb894ce3c54fb7cfc92eaac87c7dfd6cc9e62924c6c27f90b5b20c8e27cfdae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c520101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c0297229e84d3293c968f2d6bda4910b618213d600950beef17e0a31300038279050e9a2ab8e3f8760a0c710f620f3782285ddbccc30d1052d85ded7e91f2e90fdae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c530101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020d2b56df3df41975d8d86daf76328e439a5742714b03f036107d33ef02fc5910b967da0754ee860c100650b978c4631c2475e08201fb419c168fe75430d9537e0feae3e5dffff7f20070000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c540101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000203b69e1a46ccec282ecee3d3fa7caf445b6af44cb835ee364fefe55e1568c4e03ec4689bb7de3436a6699ee6131891732d24dd50c9d10c4b710092b3c6f42dd94feae3e5dffff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c550101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a0740a8851ecf8dee724c1439ae1e41d36662dfee647e63273bc4b712e547c72d9d1f74c610fc82c269e1f745c76b856929ce97b3c742d9f20684e4db7af80affeae3e5dffff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c560101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000207584e34d22e29fdbaf41dd4e008c9e8484333fa388ae435ecbeb5c0ee7055f1328650c6f963f174375b9d58a00590b65e610ffa330b60f297977c8f7d4f7ae75feae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c570101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020e0ca49a7e455619f042730864472e0fdd56fe50a93a442f8771f34b74b9c23164e2d203ec788a7e63305b013a158534c0256122aa11a365bc82d2cd5d48a96c1ffae3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c580101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000207cb695ce37dbc0304bcc3de4a48af1592d214c12ebdfeba3a93226a46ef3e4625267144e15c69054189790a40115c5ad8e2bcfbce5ad35c9716cd622d0a22d5dffae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c590101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020418601965e3425639211ed9bfe548b64032e04b4a09d8678ab364b3c12432b0273f7cfa05ba9dc5d7b2912c468064bad58fa5d1361940019f770ad7d935a612dffae3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002090fa44e5eeb49c033ca107b06b5fb4b3f4853d1e8c9eda085220555948387053bb908de4cd1a4dd37cc55673a9c83d7620dbd54e3866e1986df94e5bb0a32422ffae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020651531451f950cb180c42268ae52ff12f5468bc8d253fb62dc787713786fca564a5ffab27e2315cc6a400b374e8859aaa67de3bc880706bf28a022bf90e2720affae3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000206826a66b525bd3582b6ecd6d41c3552b5b960469360abae55816e005d4572f2610f7de6913bd1d6754a0ff66c9c25cfc23e66700692a394c4a166901393f594bffae3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002031d35234484e6d7be919ffac7f25178166a44de3be0042d6975dd4d921c346171172d6a79b19626f7644210aba0980ecb809217cbd852ae29a004a601783d6ea00af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a994e380dd10ad4f5f9545d70708671dad34fee1adfe3751d7117f47daebba78b039ea59f25f30a2919c6adc330fb4837d506a4739c01f9e200cfb6509f4d77000af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c5f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020f354eda57d1fe7c4121dae09860a8aa1d876407f66b4d8eb6ba9b51abf31486eb77513d1e03f55b26c68bead3b704dde6d81e7b7eac8fa9beb3c9f23741e759e00af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0c600101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020855596948e4de375893215035b18ecbdd5046e78180e3a6ccd056e1e12e3a16766b6230d60ead56152fbb95ea4bb7ebeedcf288f316ed4dba6b9feab48b72e9200af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01110101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000201470dada492622a488ef6edae8578b2695f1698624fa68b5460cb59614f1f44bc86baaf5c9997b519d43d54e4d174636319f62866367182fb658d4e677f1c6c100af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01120101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a9d11fde6a53b9a4fdeea3e1b7f7bd0563a65fd4f64ffaba5e3610c8ee29fe34d2ba93b50005955fa9b39460321714e402b49f8777d23039d0fea549ecb8ddf200af3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01130101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a86cfbb128c3b3765f9770feb1de972ec41791cc6053fa029d1b4e50daa0bc59e5e2c8e3ba67ddff5e818e6f06422a2c980d9ce319c8960417e3f1c7460d27d001af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01140101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c93d352c71a40dedcfd961345f979a41bae03d5d576e2448e35679e83e8c286e1af45f68f16fcd03b4afd878000e6e85c87c29fe96b2ed4867faa0067a58a5f901af3e5dffff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01150101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020bdfc271ed953f1f97f1905741deaaf71002f6de64dc32556cbb64b4685920a7b36191e3cc96a5f302572e79d0dda9a684ca1df3456dcc878e4773216f2556ecc01af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01160101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020476f64499f6587927bca14bba4aba5a9bd26edc719a4a82581aadf4382028358aac04b5f98111371bd8658dfb169896073887301109189bbcbfbded7ac6bf32101af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01170101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020edf57cdeaedac8d3bd8e30e9dcb160e7af86f4f90c22bcc8628fb72b40711c25d0e8c1dc01bdcb406871341e25adaeb4c0204ad663c3f046ab05a447050dab9c01af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01180101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002074d0959b9657e7e374b459098fbcec42e0688ab9b0378bc94db84700e59d3d111d5ffb2f99d664ecfe4a19def8ca04538a3eba542ce1d9298cb652ac5325946101af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01190101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002032a35987a9168e265faaf16719c2ab0178409c8e988c2c9aed70398dfe6c230e4c8f78b6dbabf44263584964dc6d7ab8b0c081e15c6b66d0639ac621df4203da02af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c54ea8853336e632c7ecb2217a05c0cb592c7a6e0259d576721279b06f66626f69d46667c0ed1f4a61f89b8089c4a3bded1e09c85a9c1024292034df3dda22cc02af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020bda7868d270391d11a4a5c9b2893b38e432139a14a91cc17570bd369d1cd884e8617ca924c9fdcbe394013624561643f06263b0f0e3154f19c439b41ef5c3afe02af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000207318476fa8aec77230058f12eeaa4173dfe172a6d96a18ea72c26f181ca73714159c3f4eda97aea3b6476376b534924f169ac0616b8e7498a7ebf8ddc2180cda02af3e5dffff7f20050000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020f69c2d1d16250b2e2fe15487ccfec5582829dec777ed814d11a982657b73154fcced0eeb3971e928a56409f5bd4599b138e9150c967218c45574cca7314d0c9702af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020097d6d6130e29141f998ec0f75e6b9081cca2c58f77a1c3457e7ef388aa4031621cc9d5d3e1785861d1186d6e2b98d0363a7e701015329f1095d4e464b16dda302af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d011f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020e0e30aa7f9945104a945693ffb06d99a47e873b5d3b89358c6c5b35629c91572afb1dab9d7d56d72929092ca5ffcedf54eca070e4a1ee4beb13d7844b687d00b03af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01200101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a085d816d1a386a7a14ea593fcc10c80c3002288f34353d3b29886cb0cea5d4756d6bfebbefbc8f231673723c984e8bf3fab45bc4ce2cb97fcfba23d8a5e019303af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01210101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020276bf02315887fcc3239ab4742e369576a2f5647d77df8458dc986fa67ae866c8c3b44989f7cfa98b4bd70140a6dfe62d1e08e6040fd9c7f2101faf0a38182d803af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01220101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000207f8d7f3ccdc937fa831d5a07d04d125729a19736f33202490a29a5da070cf875071b4606ca7a80ca328ee8aaf73dde99773064c472c6113d2ecb78ddd9ecaf7e03af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01230101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c0a51fa5f78e617a2b152e99a717c626ef4205ba27d40bea84e1da7354a9b11f1ea1f19ed0b86389be7a3cf84250ae4fea638a1b9b4c5d1f7fc8d02772ef538603af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01240101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000207c6aed7461f11b2e477dec1f71901e31a9b29da50c962b6492432be85866ec6b3a4ca3ac0aec68ada03f4792c99c6101dc7e28f7dd75e92cd34cf61048d0d56003af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01250101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020987b8c1fa17d09b669ae442161f2ead6e331b31f16df30a31c40ed99c0bc2c30e270fe0f6243ea281807d2d86429d99fa3811b83d0327a9cb92ec83e2920254704af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01260101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020ac0c66e32febed120d210b00c7bc4ca8837d7daf6528a95fd2700bceba45af5363433fde0a86bddc7a73b0ad33dc3795d7b13954eac3a7c9ce3a27b5b8b2b63404af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01270101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020b6ab687d84bf442827a095a0249ed885fa8ba80ad07f8b85519ffd246393e6772c126fe79be273718947e4f8d84b23cb00a749e894a47cba2a0770c35138572304af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01280101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020818c86781f0995cbaf913511877b0a56063fc0daf38dfc35df9e7b915c7774777d5cd38b5947ed0d5e692e46511dcce1c090d00d06c57999e8154243774c834204af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01290101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020ce09a60de8ea5c4ef0e3a978cc8e2a6f6553f9b0d497f45cace6fcbcb786d50c110ed1bd88bb25662f0d37edad65281cd0290ee453d759ddcfa2abd8281af7d104af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020e69da75c4d9de0ca885628346dc881049a621e54e4ba9c7f9b28a8d30267f915aa7e32793f0c10634104ae16cb141d33a8011ccfc1372a78bc12dd559f09453b04af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020f04b6a02552122418368fbbe2ff06c53e645d9c23c032a995e5053082b49317bbbc8dfe78d06ec8b45ce5bd73b12b14541bd8ce8aaeb776c211fb60899d10d7f05af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002033554aac61ef01e6707e094a98aeeaed6055a24724c6dc8ade13f8e410b5e267017e91213401d2c85b25a3bcf5c4892abd5fdd05e9a1c88c7db506c51b0e797705af3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000203dd7328a391034ead240eb7b9fc9923c0dde4b30b7ab746b90f714d2f9f08541f6a697c4ed25ace6ea1de91d8725c15c7e6aee76aa3dde83036cc5e35bbb2fe505af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000205069b1555baa6f2a77e49fd6ae8cc92f2475730dc459e78d83ae91b053882f56ca7be94fe40621eb884d23e6c2cc5b1e47c9c7cdfc639790de1c8d8bdb7efecb05af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d012f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002045550e1e44685f5427f69a26e756dcc005b989125af1926926dc294167b45f77374ccc6868031ca1a32101281499c42f99bec2201aed1510b3d8b265ba73431405af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01300101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000209d6750f3ee1cb6dc08ee43bfe3e298af1a11b4709ba8060760a5601051af7503ef931bc5001f30d9ed4765cc11f32ccf650b0b0a9d219636db708b5a097b987905af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01310101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002041c64d1b85786976dd5ccb17c6765ca984d835551bbd2004b463af7e7638ff6ea14c87ebfed298d3aead8270010514a2e2f154ee18d9bd51130495f3cd3a2ed006af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01320101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020059d10e3d50555f7d03af6aac0d0dd637267d6645f29be7e829d7c4203402a4da1dbb136439c9317da2a9d22e702cdcfecf9eab2d83c61a18c421028fa07082406af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01330101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020249400878c5c819db559818f8c642bec2f10b05f1da22c4dc24a0aaa848527516782b0d42714f44634ed90b40adb4ce2afbfac8ed14624451edc8274eb9bf0ea06af3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01340101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020fa6163908cce50019a5dd137c7e36d4e1f46a2022718b9469ac46c0f42fd81191348316f65b142316320ad1a81db800c6a54909a8908d9ec295c37f70beeae0006af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01350101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020f660ccf491edca33073f344294d6c549892023a0ebca3ce100f51b16e896422a7837fed416d6b40fcdd075f92abb299e5dc3027beb2dc7bfc03d24ba1d3131d506af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01360101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020623d3c27c5731c7849ef02c09338ae09ebaca8b01fb82ee5964b74e42a8c8b1263ffe0292f0007bca9935fde929dc33d2cb2343dd6eec1eab0d3c9285370bdd306af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01370101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000208fec0aec0998dff808aa61e894365330eb33e02bd68db039c97347ed10f0cf4844608d0fcd3103dbfcba35e45f102c5b6a165f107530a1dee57ebb61a8127a4607af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01380101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020273ea732b1bdc7e5d1a27886d5622998340d7f75207019aedd9f2857e7b2091f66aff85a92fafdfb7701d37e95e61ca850b1ac8d83aa0098ebeaddba4b012f5707af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01390101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002095fb442987762ffb75ac53bcae5a482a9b16f29688fc53b142a8c80e9547030cfeea96c15d21fe07642e0bc3fb1f8f7f7e3aba7c564ee5ebef31ad74bace945907af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000204ff62d8d1e0f292a018033f62118b6b2080a5cab3e6b495c1cc71ce4af760f532eb882e77b224e4f2981beed7a93deb83e298265de1cf6bea13f690449c64c2f07af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000209a8b436302e4a835343f361a176e476f08ffd2be395a1350cc82875dd9f8ee7bdb7d8c159fc0e28c29b3c78d84b014b6972c92e0a5c4c400c2db3cd78779b5db07af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020458604d5245623305c1c95f2a6c1481c37e231f55c7feb09fe4af6edc3363a6c26a70fb186c1c53925d320ea5a9f91a5a45c34addba482a1257b9707180787e707af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002078a40d9067dc1df5a9ff2c56c7b68a1fb5ccd36db5da6064c8ffd190f0e78a719744c49f321dc7555bdf93a530fcfedf0a2aea297239d9762983d35961eca23608af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002081926763bf50d959b4f4446ee6a36fd08a7799909f0965c64ed7fe2140ae6779d75e4e454436c5812b8b50d26ec3999d45f5ba4f5e7443dd6c93e3e598e48e8708af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d013f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020ee27509923a5b34397e3d08b838cce5da3f8284b864cf0f112b2469f796f8f1801a8f1d361985f3f268f559c99e0569c31c9a749aecb5bf2f7fb32889277650e08af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01400101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020d0393ff8b46d4dfff2cb8cbc52a234621aa2315e72b73fbee3800049c5428f5ce9b50d7487eade308183111a83d777012a76e9ba30edcd6c57b4b5e82809553c08af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01410101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020f8928685487b724f55b9eed6881008278a193e8695dbbde23587d5f2290cbb5ae7326c8f208a5cfbe42b1f17588723b6d87f6dcd8bc814072385b6ee059c57fb08af3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01420101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002052dfdc3eee69bee8117e6ab324732911a926c4b0f50c0ba1270bfd5ec7eae542b772c98d599e12e0d31f0b6325231a51903d96253f2ffd36d825688beb56427008af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01430101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a1682451d6e1dc07bc2787adcef3d0b54b01cf6e432795f7fe18c75476086b1af5dfb599b10e717ff51d1e452b7d81b95ee12966e45d121af3db3b7fdce39f2709af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01440101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002082621dd9b93a0527284715890d24d708c74735caa3911e2a0f24e3216ca4b22435d76890d30dc74ca01dddbf7089ce454a450b9464e18cd2ef57ab1547f1e40509af3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01450101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000203979376e3aded23a1c4cf5a29d96032b48b2fe79d93e5e6e1b82ac0876aa441139365c37d902d88b55d101060926205ecf39eec853f66bed9f8960a38175e19a09af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01460101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020fbf88f12c278a9d31a86ac4db23ecba825e4e709797394503c03e28bb2d84f6ccd9a1ecf1fb78f0deae918d7c4cec69ec5a78cbe83bc4bf3a86007fcd49a726109af3e5dffff7f20050000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01470101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002072a64d5fa12d6c182306f20530763fd88f3c78f34e5d4f27548dae339bc62268d91604be34c8ed5184efbec2e557b39129eaf8b3a6af7fed37a079ab1475e7b909af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01480101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020852810fdb8342ea03b951e3c4091a61691a4e688373b4337bf9308d749e12a3b42914188016ba1a8f15929612069b466c18b7be84744139b45b7357f30d9be0c09af3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01490101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020a1865284d852819c7914834b454c6074232bc6149ff171a5e6d8018de77a0427ecbce092c74f607d3faeedc8cdb9d0a5e12486a0fd753298ed8c290c8e5a62e30aaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000203f1e33d80e8ad13503774c520c16e3f4cfa9c7fc8de890f27ab65762948a593a76fc9b9e2c1feb40040fb339343fc7ec75f224ee96cf64d0c3e74a19731df1d80aaf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002060bc0f141abc2c39cbd380c2a873bb19f994b15e9580328a5c973c9164e3cd0b8d1faf9419aef34ebba2aeaeacc251c6f72fc8cd984b043bd34c96cee67dd8740aaf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000200da8bab855e03905beffd3f5f80af62f2195c06904e2b473347a3813bd5a67437293b495ec0672a64e92098bad1fae5756dc66254d39937303c249dbd55bd79a0aaf3e5dffff7f20080000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000202020b33af211ab559011d5524645ec6cace7e6d421504240aff408443b380c5c844178adfe02bf625556489ba9fa032f955e48befa8372ac03fc78313f81f5ab0aaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002055de3e128847e9779444c37df254e27ae64848bd313f4387e521a69740a3b01b16b30c88655d6a2b28546234448abfc94b89725ceb3392f90a88bfe4231c9d280aaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d014f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c95ed1f70d46c6f50f077bb215aa64ca8481de181925d3d1f68b938ba7a9fb16a78c01a1be5d15fd56851fdbea5675852ee8b95612fdc0fb6d6404c9de79bbb80baf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01500101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002098cd6d077d5372be2db5b0dea6ae0e2f84f4cd0d58489350d8cfbf0622630113e2e450e87381fff2ff71c9e3f9de544ea5ae54d35813ee8932f1090aa4f656ce0baf3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01510101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020066518ec278e9720795132250943bc76af640bbd8dd9bd047673df5c91be326b5f25aff8cf477b20e3ebc97b58790312386d1876c3b1cd06ea505d2c401392dd0baf3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01520101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020180a1786670b80df30a9dff70eac9f98000957f10152dc34968697d066ea38059f5c8d21c629c16479339f18438c79b682718e706b8d3acf3263ad84aced86570baf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01530101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020cbf4860b6f881758f6d71dcfa810e5da38122e878c5b099bfa871ae81fd3e040596ceba5ee82b571f8f64061ca4d9022f7e6d9acb75457765b7013267acd1c340baf3e5dffff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01540101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020d60983308cc045c477be39bd0faf65abaf9531efc3264c2f89403e6bda35d17886a727743ef5798dddca45ce0e3b78ec4a6a6ba4bbd4d71e2efebe029e63848f0baf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01550101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020e3da2c18cc8743d6f9b6fb671bec7de0be1f5b3addf524f54954962839f44a5c1481f4e1446f2e82bdad3fc56ba71fd85d90092be9d4b2ca2cb23cbc9278f1df0caf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01560101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000201690b43645707eacf0b90021e78ca06efb56e73cf88605dc16a99d48f95d6c64549d34adb3aa78c5a91f7b353303f9955ea3e707a8b569f31f8581514616c66f0caf3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01570101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000205ffa114b5d07ec73994e33574cf47a3849399ef0bcef5b3e28183c7809956b36cf98c852c8cb2780c149ee0b939a0a65005d55488127a45103c14694a27e04c00caf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01580101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000201e63eaa9f3f4352299d3365d87a67a2113aa1766f295d2c8aa75d90808cac20b3477ef9069accc89ff24aae58dfc0533c06790815d1ae497375598d2298639210caf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01590101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020077d1ec43ef98bfe8493d6241258d0c96a47fb57ba32d5300983732294e9dd4c31ae8e66eaf630acc8f92ab418c90dd63511dc6329bca92e455d189a5fa3da4d0caf3e5dffff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015a0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020543d35799aa94a2811cf51f1cebe3c368ea1664591ccb5773d737f3ef455c6553f84fb2dce964710c2a967c969486280615d6a24c23e299cacb89248909936910caf3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015b0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002083d4badb13fead2214c5b9e80de4083472ba4a12f376d0efaf5c33d66218215ff50fa117390ec818dd4d01e39cf1243a77930d1d432284d44ad5665fed8ebdf90daf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015c0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020e40b8b1acae19f7778538c69ee0d6defc851f3737089289df88b90210307de1c0006f17f9e19d453d649f899ce60d805e7969c76a9a3896c9c635398f566eee50daf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015d0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000204105546a9150a7fda81f855f789dc7e74c449fd1e90452d8505a098d4d328b113dbd0b909fcb4d0bf698dde11bf868cbed62ba1d73025178abfaac737496cbcc0daf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015e0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020eafecc64b055e27f27c9970bed106ca394db15a7b37f2d10b686ee3161b5a039a2e190ac4ff4d92e71f3480f0486f8f8d19a5072546cc88b2d3ee0c4ae6e320b0daf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d015f0101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000203594cb0c8d6c44fcb3276245947ba08affaced26df41fe190c15e602d7d8b26b5854adc7c9168972e7948190e88a246b6b16689231337226890076a703b375220daf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01600101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020b8de96b624d05db102e4d00cb01e167e9562a1bfd38c2e1b4ca9f31e5e8f5f63d132cb86b30801682b7eb051b66156e07c7bc17f59288f7821698d836bb5f79c0daf3e5dffff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01610101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000202e6b1b2274f2343d8ba90516444633e802b18242750b8a466351e85ff0b62a67483769f2dca54c9d48ed4056e854d1e3f86e2a5470cbb2f54590f04f2909fe160eaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01620101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "0000002034a40347b6ac7c059eae4f7fc4cfdf8293170bcf7b9de7cbeb74a5596f23512c3e677d5d36d96494a8e5aa4e51c9ee584931edaeed45bb39f6e7cef8cc73b1440eaf3e5dffff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01630101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "000000209b5ebe3f645d941812f524c5f195b5f4c202d5d85d893519bee812f6a45e8c3e9003ebe6f07138bd8b2ea87ab53daf97e59d36dbfd1bca923fc6ec5224e0bad80eaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01640101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020c97362443ee44a505c2d103ef639f9700e04098c374257fa7fde93d12edabe1fcc64a08492c6297a6de8163441eddfb4f930bb85771ed944370d9377ad16b7750eaf3e5dffff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01650101082f454233322e302fffffffff0100f2052a0100000023210295b3f2a34ce06d50236eb6cf6faf28b00e183b9ec8e08d4e86bcbd770780b98fac00000000",
-    "00000020926cae5c4df5b8bfa22a69deda736348bfac3105ae4de6183dcfc7f8cf2aa67803bda646a6b744182b820a12ff3cdb42c9c1706905d557e312e97ccda499f2970eaf3e5dffff7f20000000000202000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01660101082f454233322e302fffffffff01c0f2052a010000002321039d727b812c66518bc0eea6e3cbee143671320982e680114b7929e22ed0e90d2fac000000000200000001603cceb3f73a7cb716e4302f895f710a6b2009fef95644e20bb63d48f5036c9500000000484730440220775e2fc69304f0dad57d52f68a907743fff75e8b76a02e7c6f175a767d3463f4022061d14b3e24c6923d987b4c17e317dc1b1ec2c6c34e1f20deedf68f97eab9762541feffffff0200286bee000000001976a914f6b0a1ca060a9efb017e24864af78cd7dbdfe3cf88ac40c99a3b000000001976a914db856722ecc6ec4384a829dfc11b6fa13be5d49688ac65000000",
-    "00000020fecc584e156ced58667116adc01c1734bae5a1b07ae7107bac62c27c08f5e0618d19fd58766ec3e05db1c5d1350dcfd10311f1eba7275cade3749626685a57fd0eaf3e5dffff7f20000000000402000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0d01670101082f454233322e302fffffffff017afc062a01000000232102e2a7b752674549a7cd7ab1c223ba1d5625ffbc264ccb78309e0904ef57e6c97dac0000000002000000015104c87bd0b351ac8db6f0751d88f91521951a6886a28ecf8077b043f2269ea2000000006a473044022018fb5b50734a674002f17e0a001ef43a5882b4692612b0e2edcd99ba35613ca0022050dfdf34d6a6a4e6be8641a9b15dd4d189c0b9d482e4a2eae72692d78d24fc1741210317de7ed25740360d259b69f7ee0424141413d0f390f97d43393b8a2b0e47f8bcfeffffff02005ed0b2000000001976a9143eab965a0ad02931cb35f07831a7380657c2d75188ac1ec99a3b000000001976a9148c02f3ed52eca01c36c3a297d654274d4ceff1ae88ac6600000002000000015104c87bd0b351ac8db6f0751d88f91521951a6886a28ecf8077b043f2269ea2010000006a47304402205a683139bb02036f22c586504b3ef1e4e277506a5fb77d7527078cb87ffc269f022079dadf2773ce4c9066ad3ffbeec52ebf80013fc19650b41d2f7fbdc817276d88412103fa5bd147600176539310fff685df6bae8486a78872b4d8e88ba60571894d3a8cfeffffff0240e8a435000000001976a9142457f993fecf4eedbb0f015affa4403793f888d188ac28d8f405000000001976a9145028dd7b86c119d50fa4e022a0c6741a4e3f9b4488ac660000000200000001ab6fdeb894ce3c54fb7cfc92eaac87c7dfd6cc9e62924c6c27f90b5b20c8e27c0000000049483045022100d76b717ffe3c67b580f2971ec0457c19e14b26f25ece8ca09c5fff3d9a0160c5022027cf7e9784dc66ac09b100e3c7cb24386894af829e9955f652d9124898db795041feffffff0200ca9a3b000000001976a914352f9afc79af6613cde35bd314edd884119ca5c588ac40276bee000000001976a914344471651783fc715833b477f89677d69f3a271788ac66000000"
+    "0000002006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f05c5f72f5d6da3085583e75ee79340eb4eff208c89988e7ed0efb30b87298fa3194ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f510101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002059edda517fd40f325209ff637cb09e57a57a4fcf3996a91159883883173bc020290a5e3decf29ecef819d5bb6325c9a31c8c0776198e53d2ec063549e8dba7141a4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f520101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020fa6031a13431d3c7e6736ff6eec6d6f788fc921460fce42ddd9784c23f59cc14bfd84ecad3dfae7049e9511fb8e4f00c2fb50ad9cbf3199dcdc846bd0239b7c21a4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f530101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020b00d94fa5039c42ac0ff16746c3a7fb5a32fab104b8860cbb5ddce5db08cb72b7fc89c7179bede8976a1cffa5e5a136fc157b553ef3d8e57a21e18c7439106cb1b4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f540101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205f28d13c20222f1103c73038ddec278dfb8b74578f6772b618691edcda49eb2daf2ddb60e46d5febc513527738589aee28633e80b1c52c0ad2bade88a436d0b01b4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f550101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002052942b8b2a7b0665aacffdb783b93aeb06b2459f63b2a5a436ff063088bd0c408f259cbb364cff973c79abd829237447d5896bf710888a447a1da20e41d94f821b4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f560101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000202c70e730f565c59bf22b7b3953ce450eecef8787d1772552ac003501c3202736042a519ae0e663e229cac4ebc63682d79a7ccf41c2ec8ec3d501ec4acc22ad171b4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f570101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020b5bf9d76d7a679dc611246f34c986e63840d965f36d18618da2e38b50ae6904e818bc7e17a97a846ae151e75c64bc9dfcf72c50a977ef537144aa44c32799fec1c4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f580101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002087ca4d3708af0817cf527dae5006f717bf195ff3148aa071118c5c0badd1e931d9be7c7f539ec216afd83638010c0663b5106c49784651b394c3060ac5ceefb21c4ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f590101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020522e7852ceb2b4e4dd03816d9a310220fdfa56ebc020f492a600e712cbfba9117ad4ead415b2663f05872d140a64cab6c07019871e78051374cf2421a8d7246b1c4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5a0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f33d24c987817611a8f69cbd2c16d9941561992f708f480af32c82031d0aa5371ec94fd47feaf46ba41dbca83b4c82bbc0f54a13a71a4d23bbc606a58919135d1c4ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5b0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020ef7b799800e07164fe7802f7128d58c49e1b039bb9c4cb1834bde2a97685771bb567e06bafefbbe5a31e76c8ffd83348c58c7f523fd3c154e71a6e242a4a27881c4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5c0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002056c4a58b4e8af4d2774ab2b70d3500013fbf5673799d8a1c23ebe969e25f5f125422cf24a6d01e81080ba59001d9e26e3cf8ef8415d226bcaf7ac4367936d7411c4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5d0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020ea3407818389d64a23b02df7a9f1dd86f26957f586e40a3f7ccbcf40995e32093021bf163fad8e64fe53c60572e92fa91388aef8e94e13eea92f732495a877df1d4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5e0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000207b04e79b73d0ea645e3abd4ec54bed200cef19d25292dc1b354b95943acb714890ced93e8a2664eb1ad3ebd5630df026cd7acf533997e5644768304521d2c3071d4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f5f0101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000209a3da7809d36281c89b9120517f565d12d7456dc652edb4fc7da62ee1e03fa4a5418a893920efcdcae2dc82ed7956e6ca749136d43ef9eb1b485dbc626904baf1d4ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f600101082f454233322e302f020000ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020735d257b62ecbeea12269687f5e6145f79a8f81b6059821fbd9c2f59cf726503066020e295e72e4e3cf7f3d5396c19087bc440b05f8824b093be85955fb3177b1d4ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01110101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a12418aa84f94d087ef8bee8cdf6722020e6c245856c1f0688d503b40ad60a223a87d9a64d2bc0a61f3cb111f8a90eb61ed9a22924273640d5b777b7b996f3ed1d4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01120101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f1fa75d1913777d20984de4f60aa96ee22080239adb86fc178282d69f16bbc02b3b51185f4ae33ae85f760041e18b73324909cb02b809241da33329306d5e9cc1d4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01130101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a81502121019cd65ee8dbadf7687798abcfcd04ef184dfcb3981e6a15a9828216a600907be5b07058f55b666295a33a65a41cfabcc10d0c1f4ba721063ea47231e4ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01140101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f8d30c529b5b978fd64f8fa2938e859fb88b5db99022b4e3dc1e4826ea214c3d6566aeda8939d15fdea3e74998cc4d35475d30ff9bb5ccc30044d4fd4aa46ad21e4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01150101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000201a430bb8a2684e2099cd480d7ce7931c0196d6c1a9b960f511433df0a08ff359759900d2564c28b0855e4fe37093d0b2d2755854f7600b968a57502e633034221e4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01160101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000206cbb59f89b2e4a091c523e7562526b0d6c10ee44acad4a1df09800db23a76a4381cba840606219d14294251fdfe314f88da735e403242488e09494be02d00f2d1e4ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01170101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000200e4f76b98a1070b980915b7269a947c2d3f992315dee625a5b0845be5c75bc54d5edca00269854d7803822fab4a6d0ae6c3209ac0a9fd95a78d183363e0e2a811e4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01180101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020ab07bae60c3c9ae050078df5b25a99fd4efba7a1850ef88e7d285d39a88baa6af460179022cb654958967022a62c73e969fced52cb5c7fe3bddbd763f77b3ecf1e4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01190101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f2e37cfeacd50894fd4a0b03ca2168239216c087face9c545287d181bf8568763bcbd9b3f6c8dc144b36610efefde0fc258284cb977e04a5bbc807595ff700371f4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011a0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000209c45b8dc86a6c391adff4d42711395e6132a4bf69bfa31cec01b2066afad921f519a3f0f34358a00f2c976cd6ef181d4732c87deb281affa47148af6855600481f4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011b0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002075c6b135d7a64af0cc5ad7b57c4e2ff4d9962068c75b6cbd8396c10062afa1190c005e5ce7235a85edc80dd925457a1e4430be3ee2fc441d2c5a4a91c0c0222f1f4ae75affff7f200b0000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011c0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020475e32abe1c870d54311ce00cd5a536be9e9b478eaf3ff2fdcfe3d11414dc803f900b1d8059c29f9472e434252352aa5e7ff18c4178247157fb2e118d15c62b31f4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011d0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020016ccae54d04937295c13c162ff42c0257d3baa7322362240183eb0dea5cda34175b1a0ebb318f059e392a738212d0f28a53e99d38a0a7e714f56fab654866dc1f4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011e0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002041b0385c6c3eaa7db201934e1effafa4c1ba4c8f97de16a92efdb7ada050293256c14d0e403d35831bfd41b5d23da11593009cca00b37990a5821750f349cb071f4ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f011f0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000203111530c243fe6e6750702fb7b57f6264ecbb37386db0c4bbabb3fda76edd651b342dff173fa61b4f3f24dd0f8e10bfa9a849183258c6a6f38772174261b5634204ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01200101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000201552f6879ce21ba4654e0b66e73a0fddb76e22beb42c0c608be72faa5f572026311c183b9a3c76e008f583b0895f64b27e5ab3ec1587f180347581e783107a66204ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01210101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000209b0cfeb6916a588497da7609a686b72e2e4ea12f21ae112a8906886593af105c98457a1c7ee2e3da4d58c9e8f6eec3a47d092cde747721e89fac970d95148730204ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01220101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002032213855ef899b504229add8a71930f4d53118274e721512f8c51a1a31af4c1ca5c4ff09a294302e373702e8bce86bde3336292163c5e767f09f0efba68d3e02204ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01230101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000208cc24e11709024a436fccfb21616a64cb65b32778f82586523b6b736f8a5067710b932a617253ae376748e938ab604c81d017b30aca8b7047e0e4ad70438e7a9204ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01240101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205372fb56e6299bc08e5b4be3eca2e1de3e543e1f7e41bac2e2d13218d3bb3e00a24f52bc1c388e8be28c7ec975ae51ffe6eba3b9d7270f6892267c26f004ee25204ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01250101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205f935fcd7bb53564e5e82bdbb01851210e7887ad7dcf62914ec02c88e5da5010abe3c263ec01da20cdb827ab58efbc2d91bdf1b1c9eab1f13b7ef2f48d73cba0214ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01260101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020991747b03af816bcfe1d771c1e4bd41b962a4764cb70d2cfa9452f4eb125533afea040bb3aedef0184b3c3c2ece83963f6867af2da5657a2d20f771fa0c3bd44214ae75affff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01270101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020455fa2b8d896201a065ea7f5fdbc95618eff76774c3f844e7e6fe845b7794a2d7e14c717b1d7cd13dd1c35840da2ed14277a6045b06252d5584e1ec0cd0aac15214ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01280101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020212618756837f587af0d2ee0e6d816c2fe2c5a0b8ae16f104597323997bfd6505bff966735e2422b228844e16be40225e8074265cef6d4009c3c58d015cfbe31214ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01290101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020aaed9011205512be1abb8350abe6e4fdcb60d4a25c1383e7026042c7468a87692505ab4aefa0259d97d777c88615aecc971b79047ce2d93fc8cb8323fc530106214ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012a0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020db1b2546a22802ceb49af9e404753fa262184eee3e8a114cb0fa14b92d61d81f8017a12ab1a96a4b5bdcb41a70a7e4ef40e1e05a3f4709de49e1eaf20a98e716214ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012b0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002045de89366be117704fb3e5b58d7bef576abb922f4ed21cf4d1984178c80334344ed4fe13da35bb2433edfa1d1e07ee48cafdef12b6db99058e54d747a3a99e42224ae75affff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012c0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000206d9c18f863844f9f996ffb3322f60d479b4978e57e9e9806f9bb182e6991740a27da6307181aeda899ba154df2a304d23d9a55604e806088bbbe2f4d7f4d6324224ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012d0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f0c5de5e2d7bd66c28ca4b5637fbacda6de1fc0874ecab0708c80af50de5d32d016aabcc33c1f368d6befd9e7943964a62bc17c5b53697b826fd723d90c71b56224ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012e0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000200fb8496342f29d063d246a192ded59ef466adc6f26f66ea396f9bbbf0ff42d39d2d539072d9c6a3ffb984ca917ee0b33ffe5771b5342524435383fb4044961b3224ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f012f0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020eba9cb86a10a42b0f5f286eaa1aadbc86a4d3718541b40bf2db41b14b92c8b6c4cc12f3ec5d9b9079815f992b2e08ded31280c398b88ee290bed6992ed39957d224ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01300101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a57a18b94c1714ea23eaef81fcfa4e4408402edceace5e116b480438ce2e6f4969206abadcab3aa431828367ca3336d9272bb8da8b80f67f719eb43535dfc3c6224ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01310101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020eef6dd6ea1d190afc766fa548d0fa7d476636683af27ce6e7a4533777774ad3981e6f90fd4af5f2a069b1c56f26fdc3ca4494978f694ecde35f9da6764bd0aaf234ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01320101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a247081d2353d9f4e7773a52d5fa9938b19b0f90e23562b3cfda0dd8dac6555d18d645c7edae8b9416b7af709efb632ef1ae0388c9b852fd6e900b84efe957b9234ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01330101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020af342558da966f8ee26e22ca7dc1c2d9b74ac86bcaf5dcc3ce8848e2b70d486d56cb5914727471ee18bfaf43e5174bb4af879c06c3e5a4f0fa1392016fac2373234ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01340101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205acb790c53142fe2d09c76e898d2d6f4267d506a1ff5803aed20bdce99aa901d813b77067fb4c752dbb4e8652cf1cd87431a20ca0f0c933ef064a8118a9beb0a234ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01350101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020d6be749a5ecf079cdc6cee698c8feca7d1cc252ac9a0aaff25a1bed4a32b4743fe0c5cc5c5bd9a8af2e2d5306960ef03416abe4d9b3f9458e126ce0904bbd99e234ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01360101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020086beb8b5e5cf87c2043af4d354ec1d35e5ccf56cc7b98076dddca5913eb1204969112e019c1b503c10a279f7b1118b8d8fa3f06bc3e9acf3241d3f8aad7abe5234ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01370101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020dada0bfd78900f4bd6a1af5c8113cfa4df8bf17b7a9b4cd1ad9666c0ab1a776eb8ba46a3a741145b1a167ea89d187a46469f4c9f72c5014e9c2dd5e628504720244ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01380101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002027e648724d273440ac29266167820a59540d0e46c8f945afd226885c95b3d93178c06819212994d9de4199046004cd3c918bf66c06ea698367c66bcb99ffeea8244ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01390101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000208bb802e0b250f6581b0ad779c0bfc70178a1a3382b3e8cfcd6ab4bc488edcc2f35f0f5f9f6048d0cf39d92f02c079846b7b8892ce589a51c1d5e2a8cd9e64f42244ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013a0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a2cf81f4f4bf14aa669517ef0faccdd42cb50eaa29da3d91f09d419feb032c2c374c3e6edda32bda2d320cd4165d0d953cec99f8eb2063d80977fb49a67f130c244ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013b0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205df9cc6ff50c45418fccaa77dc977dead2b82467ce3d0a4e11a258b55f60e45940fa0652178e1a6a14d1d0b0c425d16e672c4c9a9cd8bf106a27ff8c032ebf83244ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013c0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020e3e4b897cb10171179a3ac4f03f2962afdb3392af2984c9d5ac7112e1a1d740420d63103385cb561732bd3149228d8c50074ab1e1b719195a7bf2f2d58030853244ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013d0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020fe83efd0801550eb20bcefeebeb60cc5a9a848ef728e104e5560a70b0ec3ca4ff9fde06edb6d559f1572dcd24a8989f36016589cee62ebaa747dd91359ec173d254ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013e0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020caaf425af909136270e14b6bb3939acca4ce3bdb3c6d0f5e697f2c7cd453363a79efa85492883b533962e7dfde24845888900cd359b0bdc67083f7484f4f5e92254ae75affff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f013f0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020391c5a35679c55561d620405449ed56a28523d0de89a72690070d65c125dcb5fdc440c870669e9ae88f4ca0772ccab915bb98d03085fea3816cb03532da601f8254ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01400101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002009a780ab1368962cc2581eea70e85001ccff594c4632b4912c209cbb0dacac0529a777b1249f08c94d232aa39d4b9fbe9ffb78a12a494b87f9205d069e607a03254ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01410101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002069cfc81ac48ab8bbd03169e10af15844ce3e546e7dfae46f581a683280d7c03975c8b863e3850f9357b32d02cc533fa3f8d512d1fd4c3d6c96b35450a97e6933254ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01420101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020b98378035eddf8db106e65a2fe098988a04de3385347d7a16428a886f934fa61117a0992d9e4f1f7fec0180236f063fb8d2fa7b3e5af5ecbcf524bbe306f46a9254ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01430101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002085cb81e4ea539d8bdd3f8fedd8d9664f30615ea41833d621af2b130d1fce735a537b960263888ccd07985402338f9f2ca4fffdbffcc20c26fff1b1f6684fab10264ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01440101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000207c0024f5a08e97da8cfac34b75282d3af5424903b70c4012bdc6d24a5bbfd6442bc3021ebb66d045010fb79e2065a0a1afa4e982e94083d325aebbc8383a0682264ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01450101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f2f2388fc7a228c68d6158d9c913909e57515556d84aa6d8d43f4a8f735e3d3f6115d03dca6963b2ef2b2274eada3bb37f776db275d3a0781d383e1dd4aace2f264ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01460101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020dd7205d2817518e69e21522f846f170eecda41dbd8cd320928a793dc4312840f742585219a427da8f1100c4c1cea1d451ba8735787ebaa2c31a706bb7d15a78e264ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01470101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020e644d5e43dd26a708d8f854698c56976ac886fd1f4f2598651d7e0c5c96e0f7339c2f49528a192d8e39903c952f917589f208a800147716e053a221162d55225264ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01480101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000208902dda92498d34022c25b2fca163930d9a4690551f04ef1e5cf7841cac8e72b6cb7299ccedba0af6a55b819b686ed6d7ea64b17c5ab6ab240972afd30d714bd264ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01490101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002065ca0c01f7f1224cb92a34dfd8223acbe0527f181b70ccb41afa7514afe9f82371fbf507769b203a0dbf88fdf144f9c8d1d24aaa4112991f031e10e671476362274ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014a0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000207a7e9a3588db2f7fa103c2b70dbba0b6a2b63fac1a9a8042e555e97e1411a14e546185c553dbe70874b8d01d777760d1a8a711843648a70cc713b094d8614c7b274ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014b0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002076694d416421cde83d7766af651f3ba5648a0661b12fd4b2b5d4a3258661e1039d205fae743d3fdf45a6263e60f31ceae5f08d1a25e0c9f0623bba0cec88e074274ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014c0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a0905a6b411af2ea9663b959585d47500f181b9dacba2249aca98be4c119dd4fd5c608097db31fec92db207fe8f8a2a6c2fce52164afdae99f8dfa305ab60aae274ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014d0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002019437bda1d49679f4f0c209efedb1c57ee0440c32ec78fe55efd110206478557008ed3339fa53a0e2c58a42fc3709bf30974f6195e1cf7a6dc5af5cd03d372d2274ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014e0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000201ac5df6ff9f8606dcdf765ac1c8d601777f918bc688d401c9e3cefe00b84506e958dea48d6816a2c4d8d1cd5208e9e75c5a332b1623a1c59f1a49711ef3e6763274ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f014f0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000206003d23f072d18cf43507a9a5c2203145d608c3f549d22dc1964a22956cb5928a411e8745618f521719c4ee5b3a701f16c09f79feadf02c392bef3d54507fe08284ae75affff7f20020000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01500101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f2bc6a8251a8ffb8f8593129e2014a902f43975530d0eb25e14aff1c0ab1833dccb498798ce6cc6974dcfe0ba1f61607fcac1b252be7d2e24b11a5da7141a022284ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01510101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020b9aa528192f167604d88478aefed464d0d508ad30683a8d5c49e86bb2e28f814f6d311a7cd9818f9ee0b7566889e80e778735db7b23373ab839bc574376eadf0284ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01520101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000209ffcc98849b428c47d9b8ff7577fdaeb8281e0d04dde36d4b665071676275c17616e38f30433eeb5bc3f40d8643f0b92ab31c40c7e3f51e062731bf2cb43dff0284ae75affff7f20040000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01530101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000207660a6836474d074afa5e394e9de07ac519312a856fdca952354581dec98484d1cab2e676890ebffa46dd587f9d743db12f8ed63dc1522d65700ef143afcf486284ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01540101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000204feebca1ee4c76be636b6350644ed708b3cdb671d9cf4938f3348bfefa309a6b87474299b1fad208fb1d8fd47433d9c84671544b38ba1660bff0e691b2ddba7c284ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01550101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002073000e74e0e62c7ae1d6eb442553b6e9a28ae1773e1bf99d6debbae26bb72812e5a5598eb5d4eb93a4470c1a2ca0c00d2bbf0eddac8e5c4af8f0870447bc0c94294ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01560101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020c95e2e44260674cee71e65c0c957e9e24fe1371be28f024f582f7b094c9a6c6af4a4448150d0612d2d8ade42281765334349b450bf7d264de5a0fb8683f79ab5294ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01570101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020fda3d3a0f90125539d3dc9486f9204df9e5c6617e8a5b95376a0f86cfe529c00d29fc1df5010b8e81a9f91dd10570b4194f3624763b8c1a19beee896bc5c5bc4294ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01580101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020874c69768505ac7a68ba806b7a416f9ad738b8f9d2670ee766172726c878d7347476e8023b1c185b4b093c7c047d7a3c4cc33ac55b3cc8289e4d6aa34481a5f5294ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01590101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020f54086e370de2245c82c4cfb33fcbdfddb5ced94b57720a98024888da1a0a929f3eab66ca986518ae7a7c9f2e17bba0fd4106221cd4a21fcd7c4ca81232915a5294ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015a0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002037a6017e2708f4bddc2ae5a7fb6356ef677da0825204e5584e41bbd4dcfe3e6d7cf3dd1fadb0a6de6a79ce4bc436eb4bfa3d084eea16c2a8755b2d7f9aae0af6294ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015b0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000209fd12c3379c81cd804e9abf66ceaadd9093a2dab8a9576b0de8904c520c50e4cbdbdaabe755ae271f9f86a860f88f0c6c2a944f0ebdae3af375444d9ef0dcfa12a4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015c0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020509ffd1b28ca8c5a7cc8530a115517324cc6c159b8885a4a457d37366effb749d53fd9b67cfddba5e9870de737e1e2a1b58dcfba377095ad015a0b0b883043322a4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015d0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000206895f0ffccc0d1bfc158ba132a23d92e4d50a2d2717fe28e4e43dcd3d53c80590472e5f9ef79a9a070cc2bbd19416299282cb50c681b3cb0dd256f6810dfd3192a4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015e0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020d182f4da283a2a815e60d02e6c1727b3dd0ba23c2fc849dde00567beea4a7f724bfcfc029597d943a01c25a6a06ccd4b5e1b02cbbf40172bda793063811251222a4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f015f0101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020fc9a74d8312fc37d1027c848dfd0c20cfc7cef8f79239beecbd2022f3179462f73dbb55b0fa7aaecb3a9286d5206d11bb20e0b050ecd2a5240805fc9d7a76acb2a4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01600101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002037d0cf6304bf1b519be55cf3f7e15605a84bd9db222554f227b0d922e4129f3a85070dd8abc62650738c9f633addb1f19c1b16b073f5e8ffb44c88784fedc35b2a4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01610101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "0000002072ffe22421c091ea11313ffe40b92d32b6f987b5764625d709de8ea7d4c5bc53c8ca535211867f1e0e7e57fee5a510a7435903a86fdea5320ea93b7f95a81b792b4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01620101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000205bd302491bc690cea24422e800747fa3fd1b6fb137fb5018c47b11ad90c52755e2124f3b902a4f368a89d03058d0fbd69ce494ba6055bf299f5ed9d75a755fb62b4ae75affff7f20010000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01630101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020a7dcc55b04a546cddd1c764e69337ed230834ca66fd51bd23adcb673734d7c5c053a47d82618fa4df6a0db6f0d9e677c44945bba6f413fec44b29b25a770057f2b4ae75affff7f20030000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01640101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "00000020818587bde832de22be348e70c58e5cecb25c0395bff51405a8fd3b9fad1042688109df13eb0a5c0cf872f0b9105c13345cb577fcb5c67654556ae163d51083ce2b4ae75affff7f20000000000102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01650101082f454233322e302f0100ffffffff0100f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000",
+    "000000201e2815a75750af357dcb654f9f428dda7a504365c6fab2c1ef877de60ae1c241647fc8d4d1a48d1374a4bfb7ecad1493058dea42e5ee87edfc12abc50e2616a02b4ae75affff7f20020000000202000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01660101082f454233322e302f0100ffffffff01e1f2052a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00000000020000000105c5f72f5d6da3085583e75ee79340eb4eff208c89988e7ed0efb30b87298fa3000000006a4730440220581f48d1a5c9c4a869cec92dbe94df5c3c28a8c27d638b23e24919c4e6aee71c022024e0357d5a5976e6d201bb2f53a6251b89daeda785dfb9c6fcb610da0d1e3ed541210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3ffeffffff0200286bee000000001976a91449f2f195be42ed62b12a8f9da073abcbecb9c10288ac1fc99a3b000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac65000000",
+    "00000020421d192d36ce9f0e4f2082ed947acc18b7eedc7c1f30cd79e26484ce36f3ae04fb9002c4cfb89aa6d302c2eabe7c38ccb9ac56c0c182b81357f154fde7f7655b2b4ae75affff7f20000000000402000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f01670101082f454233322e302f0100ffffffff016efb062a010000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac000000000200000001c4d80cdcd39a6f766d637a6ac63a35255e022bda33e02d6d68202bdff1ecea6c010000006a47304402202a8e13786869874071d527f36102241df28f779a3272ea6d5f5aa89c544af47e0220262c806e828530d8a90f8677ceff72720e53e082e4228a2240dcfa6a0cc000d041210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3ffeffffff0254d9f405000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac1fe8a435000000001976a91401df140f86cf2f6e91584e0a0d9b13579687881d88ac660000000200000001290a5e3decf29ecef819d5bb6325c9a31c8c0776198e53d2ec063549e8dba714000000006a4730440220496af6043dae18fc4b655a33bbc35680e208a37d1f6b8c2633835c1d6ff9d45602205cff70466b2d8b76f83be9a7cf711e0197cf3a60965b62525816bc67cc2f856741210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3ffeffffff021f276bee000000001976a914a138a9c7be324a2027b6c19c3ecdb7a83fccf76188ac00ca9a3b000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac660000000200000001c4d80cdcd39a6f766d637a6ac63a35255e022bda33e02d6d68202bdff1ecea6c000000006a47304402203a8437f161265e6ea527ae7ba2c766eb4843b9d9240a1cec27f7ae98bcbb4200022037d5b5ff17c61b7218c02fba92e9cd8226f8cb0ebc24695f499339590ac49597412102c9785a4f32000e6dcde0b1d2d4e98540bece3aba965c3735fbbb0fe90fa063c3feffffff021fc99a3b000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac005ed0b2000000001976a9146fd0eb1d6092e852b49342e13edb1a757137e38d88ac66000000"
   ],
-  "mocktime": 1564389116,
+  "mocktime": 1525107225,
   "stats": [
     {
       "avgfee": 0.0,
       "avgfeerate": 0.0,
       "avgtxsize": 0,
-      "blockhash": "78a62acff8c7cf3d18e64dae0531acbf486373dade692aa2bfb8f54d5cae6c92",
+      "blockhash": "41c2e10ae67d87efc1b2fac66543507ada8d429f4f65cb7d35af5057a715281e",
       "height": 101,
       "ins": 0,
       "maxfee": 0.0,
       "maxfeerate": 0.0,
       "maxtxsize": 0,
       "medianfee": 0.0,
       "medianfeerate": 0.0,
-      "mediantime": 1564389133,
+      "mediantime": 1525107242,
       "mediantxsize": 0,
       "minfee": 0.0,
       "minfeerate": 0.0,
       "mintxsize": 0,
       "outs": 1,
       "subsidy": 50.0,
-      "time": 1564389134,
+      "time": 1525107243,
       "total_out": 0.0,
       "total_size": 0,
       "totalfee": 0.0,
       "txs": 1,
       "utxo_increase": 1,
-      "utxo_size_inc": 85
+      "utxo_size_inc": 75
     },
     {
-      "avgfee": 1.92e-06,
+      "avgfee": 2.25e-06,
       "avgfeerate": 1e-08,
-      "avgtxsize": 191,
-      "blockhash": "61e0f5087cc262ac7b10e77ab0a1e5ba34171cc0ad16716658ed6c154e58ccfe",
+      "avgtxsize": 225,
+      "blockhash": "04aef336ce8464e279cd301f7cdceeb718cc7a94ed82204f0e9fce362d191d42",
       "height": 102,
       "ins": 1,
-      "maxfee": 1.92e-06,
+      "maxfee": 2.25e-06,
       "maxfeerate": 1e-08,
-      "maxtxsize": 191,
-      "medianfee": 1.92e-06,
+      "maxtxsize": 225,
+      "medianfee": 2.25e-06,
       "medianfeerate": 1e-08,
-      "mediantime": 1564389133,
-      "mediantxsize": 191,
-      "minfee": 1.92e-06,
+      "mediantime": 1525107242,
+      "mediantxsize": 225,
+      "minfee": 2.25e-06,
       "minfeerate": 1e-08,
-      "mintxsize": 191,
+      "mintxsize": 225,
       "outs": 3,
       "subsidy": 50.0,
-      "time": 1564389134,
-      "total_out": 49.99999808,
-      "total_size": 191,
-      "totalfee": 1.92e-06,
+      "time": 1525107243,
+      "total_out": 49.99999775,
+      "total_size": 225,
+      "totalfee": 2.25e-06,
       "txs": 2,
       "utxo_increase": 2,
       "utxo_size_inc": 150
     },
     {
-      "avgfee": 0.00022739,
-      "avgfeerate": 1.06e-06,
-      "avgtxsize": 214,
-      "blockhash": "1f5619699145227f1a725669a4a755689a95cedbc0a696f1964187264c596a86",
+      "avgfee": 0.0002265,
+      "avgfeerate": 1e-06,
+      "avgtxsize": 225,
+      "blockhash": "69f1ebab8b9a8363efdde320066c31c261bc16b791d8777d3034dad8e5313116",
       "height": 103,
       "ins": 3,
-      "maxfee": 0.000678,
-      "maxfeerate": 3.01e-06,
+      "maxfee": 0.000675,
+      "maxfeerate": 3e-06,
       "maxtxsize": 225,
-      "medianfee": 2.26e-06,
+      "medianfee": 2.25e-06,
       "medianfeerate": 1e-08,
-      "mediantime": 1564389134,
+      "mediantime": 1525107243,
       "mediantxsize": 225,
-      "minfee": 1.92e-06,
+      "minfee": 2.25e-06,
       "minfeerate": 1e-08,
-      "mintxsize": 192,
+      "mintxsize": 225,
       "outs": 7,
       "subsidy": 50.0,
-      "time": 1564389134,
-      "total_out": 99.9993159,
-      "total_size": 642,
-      "totalfee": 0.00068218,
+      "time": 1525107243,
+      "total_out": 99.99931825,
+      "total_size": 675,
+      "totalfee": 0.0006795,
       "txs": 4,
       "utxo_increase": 4,
       "utxo_size_inc": 300
     }
   ]
 }
\ No newline at end of file
diff --git a/test/functional/rpc_getblockstats.py b/test/functional/rpc_getblockstats.py
index 709b60ce0..27cda6d08 100755
--- a/test/functional/rpc_getblockstats.py
+++ b/test/functional/rpc_getblockstats.py
@@ -1,219 +1,199 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #
 # Test getblockstats rpc call
 #
 import decimal
 import json
 import os
-import time
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
 )
 
 TESTSDIR = os.path.dirname(os.path.realpath(__file__))
 
 
 def EncodeDecimal(o):
     if isinstance(o, decimal.Decimal):
         # json.load will read a quoted float as a string and not convert it back
         # to decimal, so store the value as unquoted float instead.
         return float(o)
     raise TypeError(repr(o) + " is not JSON serializable")
 
 
 class GetblockstatsTest(BitcoinTestFramework):
 
     start_height = 101
     max_stat_pos = 2
-    STATS_NEED_TXINDEX = [
-        'avgfee',
-        'avgfeerate',
-        'maxfee',
-        'maxfeerate',
-        'medianfee',
-        'medianfeerate',
-        'minfee',
-        'minfeerate',
-        'totalfee',
-        'utxo_size_inc',
-    ]
 
     def add_options(self, parser):
         parser.add_argument('--gen-test-data', dest='gen_test_data',
                             default=False, action='store_true',
                             help='Generate test data')
         parser.add_argument('--test-data', dest='test_data',
                             default='data/rpc_getblockstats.json',
                             action='store', metavar='FILE',
                             help='Test data file')
 
     def set_test_params(self):
-        self.num_nodes = 2
-        self.extra_args = [['-txindex'], ['-paytxfee=0.003']]
+        self.num_nodes = 1
         self.setup_clean_chain = True
 
     def get_stats(self):
         return [self.nodes[0].getblockstats(
             hash_or_height=self.start_height + i) for i in range(self.max_stat_pos + 1)]
 
     def generate_test_data(self, filename):
-        mocktime = time.time()
+        mocktime = 1525107225
+        self.nodes[0].setmocktime(mocktime)
         self.nodes[0].generate(101)
 
+        address = self.nodes[0].get_deterministic_priv_key().address
         self.nodes[0].sendtoaddress(
-            address=self.nodes[1].getnewaddress(), amount=10, subtractfeefromamount=True)
+            address=address,
+            amount=10,
+            subtractfeefromamount=True)
         self.nodes[0].generate(1)
         self.sync_all()
 
         self.nodes[0].sendtoaddress(
-            address=self.nodes[0].getnewaddress(), amount=10, subtractfeefromamount=True)
+            address=address,
+            amount=10,
+            subtractfeefromamount=True)
+        self.nodes[0].sendtoaddress(
+            address=address,
+            amount=10,
+            subtractfeefromamount=False)
+        self.nodes[0].settxfee(amount=0.003)
         self.nodes[0].sendtoaddress(
-            address=self.nodes[0].getnewaddress(), amount=10, subtractfeefromamount=False)
-        self.nodes[1].sendtoaddress(
-            address=self.nodes[0].getnewaddress(), amount=1, subtractfeefromamount=True)
+            address=address,
+            amount=1,
+            subtractfeefromamount=True)
         self.sync_all()
         self.nodes[0].generate(1)
 
         self.expected_stats = self.get_stats()
 
         blocks = []
         tip = self.nodes[0].getbestblockhash()
         blockhash = None
         height = 0
         while tip != blockhash:
             blockhash = self.nodes[0].getblockhash(height)
             blocks.append(self.nodes[0].getblock(blockhash, 0))
             height += 1
 
         to_dump = {
             'blocks': blocks,
             'mocktime': int(mocktime),
             'stats': self.expected_stats,
         }
         with open(filename, 'w', encoding="utf8") as f:
             json.dump(to_dump, f, sort_keys=True,
                       indent=2, default=EncodeDecimal)
 
     def load_test_data(self, filename):
         with open(filename, 'r', encoding="utf8") as f:
             d = json.load(f, parse_float=decimal.Decimal)
             blocks = d['blocks']
             mocktime = d['mocktime']
             self.expected_stats = d['stats']
             self.log.info(self.expected_stats)
 
         # Set the timestamps from the file so that the nodes can get out of
         # Initial Block Download
         self.nodes[0].setmocktime(mocktime)
-        self.nodes[1].setmocktime(mocktime)
+        self.sync_all()
 
         for i, b in enumerate(blocks):
             self.nodes[0].submitblock(b)
 
     def run_test(self):
         test_data = os.path.join(TESTSDIR, self.options.test_data)
         if self.options.gen_test_data:
             self.generate_test_data(test_data)
         else:
             self.load_test_data(test_data)
 
         self.sync_all()
         stats = self.get_stats()
-        expected_stats_noindex = []
-        for stat_row in stats:
-            expected_stats_noindex.append(
-                {k: v for k, v in stat_row.items() if k not in self.STATS_NEED_TXINDEX})
 
         # Make sure all valid statistics are included but nothing else is
         expected_keys = self.expected_stats[0].keys()
         assert_equal(set(stats[0].keys()), set(expected_keys))
 
         assert_equal(stats[0]['height'], self.start_height)
         assert_equal(stats[self.max_stat_pos]['height'],
                      self.start_height + self.max_stat_pos)
 
         for i in range(self.max_stat_pos + 1):
             self.log.info('Checking block {}\n'.format(i))
             assert_equal(stats[i], self.expected_stats[i])
 
             # Check selecting block by hash too
             blockhash = self.expected_stats[i]['blockhash']
             stats_by_hash = self.nodes[0].getblockstats(
                 hash_or_height=blockhash)
             assert_equal(stats_by_hash, self.expected_stats[i])
 
-            # Check with the node that has no txindex
-            stats_no_txindex = self.nodes[1].getblockstats(
-                hash_or_height=blockhash, stats=list(expected_stats_noindex[i].keys()))
-            assert_equal(stats_no_txindex, expected_stats_noindex[i])
-
         # Make sure each stat can be queried on its own
         for stat in expected_keys:
             for i in range(self.max_stat_pos + 1):
                 result = self.nodes[0].getblockstats(
                     hash_or_height=self.start_height + i, stats=[stat])
                 assert_equal(list(result.keys()), [stat])
                 if result[stat] != self.expected_stats[i][stat]:
                     self.log.info('result[{}] ({}) failed, {!r} != {!r}'.format(
                         stat, i, result[stat], self.expected_stats[i][stat]))
                 assert_equal(result[stat], self.expected_stats[i][stat])
 
         # Make sure only the selected statistics are included (more than one)
         some_stats = {'minfee', 'maxfee'}
         stats = self.nodes[0].getblockstats(
             hash_or_height=1, stats=list(some_stats))
         assert_equal(set(stats.keys()), some_stats)
 
         # Test invalid parameters raise the proper json exceptions
         tip = self.start_height + self.max_stat_pos
         assert_raises_rpc_error(-8, 'Target block height {} after current tip {}'.format(
             tip + 1, tip), self.nodes[0].getblockstats, hash_or_height=tip + 1)
         assert_raises_rpc_error(-8, 'Target block height {} is negative'.format(-1),
                                 self.nodes[0].getblockstats, hash_or_height=-1)
 
         # Make sure not valid stats aren't allowed
         inv_sel_stat = 'asdfghjkl'
         inv_stats = [
             [inv_sel_stat],
             ['minfee', inv_sel_stat],
             [inv_sel_stat, 'minfee'],
             ['minfee', inv_sel_stat, 'maxfee'],
         ]
         for inv_stat in inv_stats:
             assert_raises_rpc_error(-8, 'Invalid selected statistic {}'.format(
                 inv_sel_stat), self.nodes[0].getblockstats, hash_or_height=1, stats=inv_stat)
 
         # Make sure we aren't always returning inv_sel_stat as the culprit stat
-        assert_raises_rpc_error(-8, 'Invalid selected statistic aaa{}'.format(inv_sel_stat),
-                                self.nodes[0].getblockstats, hash_or_height=1, stats=['minfee', 'aaa{}'.format(inv_sel_stat)])
-
-        assert_raises_rpc_error(-8, 'One or more of the selected stats requires -txindex enabled',
-                                self.nodes[1].getblockstats, hash_or_height=1)
-        assert_raises_rpc_error(-8, 'One or more of the selected stats requires -txindex enabled',
-                                self.nodes[1].getblockstats, hash_or_height=self.start_height + self.max_stat_pos)
-
         # Mainchain's genesis block shouldn't be found on regtest
         assert_raises_rpc_error(-5, 'Block not found', self.nodes[0].getblockstats,
                                 hash_or_height='000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f')
 
         # Invalid number of args
         assert_raises_rpc_error(-1,
                                 'getblockstats hash_or_height ( stats )',
                                 self.nodes[0].getblockstats,
                                 '00',
                                 1,
                                 2)
         assert_raises_rpc_error(-1,
                                 'getblockstats hash_or_height ( stats )',
                                 self.nodes[0].getblockstats)
 
 
 if __name__ == '__main__':
     GetblockstatsTest().main()