From 7314fe1aac634859323222ee9453f3c7940dfdef Mon Sep 17 00:00:00 2001
From: Ross Nicoll <jrn@jrn.me.uk>
Date: Fri, 10 Sep 2021 08:25:57 +0100
Subject: [PATCH 1/4] consensus: AuxPoW header

Add the AuxPoW header to block storage, without yet adding code to mine or validate mined AuxPoW blocks.
---
 src/Makefile.am                |   2 +
 src/Makefile.test.include      |   1 +
 src/auxpow.cpp                 | 215 ++++++++++++
 src/auxpow.h                   | 158 +++++++++
 src/chain.cpp                  |  13 +
 src/primitives/block.cpp       |  13 +
 src/primitives/block.h         |  23 ++
 src/rpc/auxpow_miner.cpp       | 154 +++++++++
 src/rpc/auxpow_miner.h         | 107 ++++++
 src/test/auxpow_tests.cpp      | 609 +++++++++++++++++++++++++++++++++
 src/test/merkle_tests.cpp      |   2 +-
 src/test/util/setup_common.cpp |   9 +
 src/test/util/setup_common.h   |   5 +
 13 files changed, 1310 insertions(+), 1 deletion(-)
 create mode 100644 src/auxpow.cpp
 create mode 100644 src/auxpow.h
 create mode 100644 src/rpc/auxpow_miner.cpp
 create mode 100644 src/rpc/auxpow_miner.h
 create mode 100644 src/test/auxpow_tests.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index d275489d512..df7cee91c2b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -107,6 +107,7 @@ BITCOIN_CORE_H = \
   addrdb.h \
   addrman.h \
   attributes.h \
+  auxpow.h \
   banman.h \
   base58.h \
   bech32.h \
@@ -489,6 +490,7 @@ libbitcoin_consensus_a_SOURCES = \
 libbitcoin_common_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_common_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_common_a_SOURCES = \
+  auxpow.cpp \
   base58.cpp \
   bech32.cpp \
   bloom.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 9902f53081f..fc2a0fe1a1c 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -214,6 +214,7 @@ BITCOIN_TESTS =\
   test/addrman_tests.cpp \
   test/amount_tests.cpp \
   test/allocator_tests.cpp \
+  test/auxpow_tests.cpp \
   test/base32_tests.cpp \
   test/base58_tests.cpp \
   test/base64_tests.cpp \
diff --git a/src/auxpow.cpp b/src/auxpow.cpp
new file mode 100644
index 00000000000..24b13ad5579
--- /dev/null
+++ b/src/auxpow.cpp
@@ -0,0 +1,215 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 Vince Durham
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Copyright (c) 2014-2019 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include <auxpow.h>
+
+#include <consensus/consensus.h>
+#include <consensus/merkle.h>
+#include <hash.h>
+#include <primitives/block.h>
+#include <script/script.h>
+#include <util/strencodings.h>
+#include <util/system.h>
+
+#include <algorithm>
+
+namespace
+{
+
+/**
+ * Decodes a 32-bit little endian integer from raw bytes.
+ */
+uint32_t
+DecodeLE32 (const unsigned char* bytes)
+{
+  uint32_t res = 0;
+  for (int i = 0; i < 4; ++i)
+    {
+      res <<= 8;
+      res |= bytes[3 - i];
+    }
+  return res;
+}
+
+} // anonymous namespace
+
+bool
+CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
+                const Consensus::Params& params) const
+{
+    if (params.fStrictChainId && parentBlock.GetChainId () == nChainId)
+        return error("Aux POW parent has our chain ID");
+
+    if (vChainMerkleBranch.size() > 30)
+        return error("Aux POW chain merkle branch too long");
+
+    // Check that the chain merkle root is in the coinbase
+    const uint256 nRootHash
+      = CheckMerkleBranch (hashAuxBlock, vChainMerkleBranch, nChainIndex);
+    std::vector<unsigned char> vchRootHash(nRootHash.begin(), nRootHash.end());
+    std::reverse (vchRootHash.begin(), vchRootHash.end()); // correct endian
+
+    // Check that we are in the parent block merkle tree
+    if (CheckMerkleBranch(coinbaseTx->GetHash(), vMerkleBranch, 0)
+          != parentBlock.hashMerkleRoot)
+        return error("Aux POW merkle root incorrect");
+
+    // Check that there is at least one input.
+    if (coinbaseTx->vin.empty())
+        return error("Aux POW coinbase has no inputs");
+
+    const CScript script = coinbaseTx->vin[0].scriptSig;
+
+    // Check that the same work is not submitted twice to our chain.
+    //
+
+    const unsigned char* const mmHeaderBegin = pchMergedMiningHeader;
+    const unsigned char* const mmHeaderEnd
+        = mmHeaderBegin + sizeof (pchMergedMiningHeader);
+    CScript::const_iterator pcHead =
+        std::search(script.begin(), script.end(), mmHeaderBegin, mmHeaderEnd);
+
+    CScript::const_iterator pc =
+        std::search(script.begin(), script.end(), vchRootHash.begin(), vchRootHash.end());
+
+    if (pc == script.end())
+        return error("Aux POW missing chain merkle root in parent coinbase");
+
+    if (pcHead != script.end())
+    {
+        // Enforce only one chain merkle root by checking that a single instance of the merged
+        // mining header exists just before.
+        if (script.end() != std::search(pcHead + 1, script.end(),
+                                        mmHeaderBegin, mmHeaderEnd))
+            return error("Multiple merged mining headers in coinbase");
+        if (pcHead + sizeof(pchMergedMiningHeader) != pc)
+            return error("Merged mining header is not just before chain merkle root");
+    }
+    else
+    {
+        // For backward compatibility.
+        // Enforce only one chain merkle root by checking that it starts early in the coinbase.
+        // 8-12 bytes are enough to encode extraNonce and nBits.
+        if (pc - script.begin() > 20)
+            return error("Aux POW chain merkle root must start in the first 20 bytes of the parent coinbase");
+    }
+
+
+    // Ensure we are at a deterministic point in the merkle leaves by hashing
+    // a nonce and our chain ID and comparing to the index.
+    pc += vchRootHash.size();
+    if (script.end() - pc < 8)
+        return error("Aux POW missing chain merkle tree size and nonce in parent coinbase");
+
+    const uint32_t nSize = DecodeLE32 (&pc[0]);
+    const unsigned merkleHeight = vChainMerkleBranch.size ();
+    if (nSize != (1u << merkleHeight))
+        return error("Aux POW merkle branch size does not match parent coinbase");
+
+    const uint32_t nNonce = DecodeLE32 (&pc[4]);
+    if (nChainIndex != getExpectedIndex (nNonce, nChainId, merkleHeight))
+        return error("Aux POW wrong index");
+
+    return true;
+}
+
+int
+CAuxPow::getExpectedIndex (uint32_t nNonce, int nChainId, unsigned h)
+{
+  // Choose a pseudo-random slot in the chain merkle tree
+  // but have it be fixed for a size/nonce/chain combination.
+  //
+  // This prevents the same work from being used twice for the
+  // same chain while reducing the chance that two chains clash
+  // for the same slot.
+
+  /* This computation can overflow the uint32 used.  This is not an issue,
+     though, since we take the mod against a power-of-two in the end anyway.
+     This also ensures that the computation is, actually, consistent
+     even if done in 64 bits as it was in the past on some systems.
+
+     Note that h is always <= 30 (enforced by the maximum allowed chain
+     merkle branch length), so that 32 bits are enough for the computation.  */
+
+  uint32_t rand = nNonce;
+  rand = rand * 1103515245 + 12345;
+  rand += nChainId;
+  rand = rand * 1103515245 + 12345;
+
+  return rand % (1u << h);
+}
+
+uint256
+CAuxPow::CheckMerkleBranch (uint256 hash,
+                            const std::vector<uint256>& vMerkleBranch,
+                            int nIndex)
+{
+  if (nIndex == -1)
+    return uint256 ();
+  for (std::vector<uint256>::const_iterator it(vMerkleBranch.begin());
+       it != vMerkleBranch.end(); ++it)
+  {
+    if (nIndex & 1)
+      hash = Hash(*it, hash);
+    else
+      hash = Hash(hash, *it);
+    nIndex >>= 1;
+  }
+  return hash;
+}
+
+std::unique_ptr<CAuxPow>
+CAuxPow::createAuxPow (const CPureBlockHeader& header)
+{
+  assert (header.IsAuxpow ());
+
+  /* Build a minimal coinbase script input for merge-mining.  */
+  const uint256 blockHash = header.GetHash();
+  std::vector<unsigned char> inputData(blockHash.begin(), blockHash.end());
+  std::reverse (inputData.begin(), inputData.end());
+  inputData.push_back (1);
+  inputData.insert (inputData.end(), 7, 0);
+
+  /* Fake a parent-block coinbase with just the required input
+     script and no outputs.  */
+  CMutableTransaction coinbase;
+  coinbase.vin.resize (1);
+  coinbase.vin[0].prevout.SetNull ();
+  coinbase.vin[0].scriptSig = (CScript () << inputData);
+  assert (coinbase.vout.empty ());
+  CTransactionRef coinbaseRef = MakeTransactionRef (coinbase);
+
+  /* Build a fake parent block with the coinbase.  */
+  CBlock parent;
+  parent.nVersion = 1;
+  parent.vtx.resize (1);
+  parent.vtx[0] = coinbaseRef;
+  parent.hashMerkleRoot = BlockMerkleRoot (parent);
+
+  /* Construct the auxpow object.  */
+  std::unique_ptr<CAuxPow> auxpow(new CAuxPow (std::move (coinbaseRef)));
+  assert (auxpow->vMerkleBranch.empty ());
+  assert (auxpow->vChainMerkleBranch.empty ());
+  auxpow->nChainIndex = 0;
+  auxpow->parentBlock = parent;
+
+  return auxpow;
+}
+
+CPureBlockHeader&
+CAuxPow::initAuxPow (CBlockHeader& header)
+{
+  /* Set auxpow flag right now, since we take the block hash below when creating
+     the minimal auxpow for header.  */
+  header.SetAuxpowFlag(true);
+
+  std::unique_ptr<CAuxPow> apow = createAuxPow (header);
+  CPureBlockHeader& result = apow->parentBlock;
+  header.SetAuxpow (std::move (apow));
+
+  return result;
+}
diff --git a/src/auxpow.h b/src/auxpow.h
new file mode 100644
index 00000000000..6e04e863002
--- /dev/null
+++ b/src/auxpow.h
@@ -0,0 +1,158 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Copyright (c) 2014-2019 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_AUXPOW_H
+#define BITCOIN_AUXPOW_H
+
+#include <consensus/params.h>
+#include <primitives/pureheader.h>
+#include <primitives/transaction.h>
+#include <serialize.h>
+#include <uint256.h>
+
+#include <cassert>
+#include <memory>
+#include <vector>
+
+class CBlock;
+class CBlockHeader;
+class CBlockIndex;
+class CValidationState;
+class UniValue;
+
+namespace auxpow_tests
+{
+class CAuxPowForTest;
+}
+
+/** Header for merge-mining data in the coinbase.  */
+static const unsigned char pchMergedMiningHeader[] = { 0xfa, 0xbe, 'm', 'm' };
+
+/**
+ * Data for the merge-mining auxpow.  This uses a merkle tx (the parent block's
+ * coinbase tx) and a second merkle branch to link the actual Namecoin block
+ * header to the parent block header, which is mined to satisfy the PoW.
+ */
+class CAuxPow
+{
+
+private:
+
+  /** The parent block's coinbase transaction.  */
+  CTransactionRef coinbaseTx;
+
+  /** The Merkle branch of the coinbase tx to the parent block's root.  */
+  std::vector<uint256> vMerkleBranch;
+
+  /** The merkle branch connecting the aux block to our coinbase.  */
+  std::vector<uint256> vChainMerkleBranch;
+
+  /** Merkle tree index of the aux block header in the coinbase.  */
+  int nChainIndex;
+
+  /** Parent block header (on which the real PoW is done).  */
+  CPureBlockHeader parentBlock;
+
+  /**
+   * Check a merkle branch.  This used to be in CBlock, but was removed
+   * upstream.  Thus include it here now.
+   */
+  static uint256 CheckMerkleBranch (uint256 hash,
+                                    const std::vector<uint256>& vMerkleBranch,
+                                    int nIndex);
+
+  friend UniValue AuxpowToJSON(const CAuxPow& auxpow);
+  friend class auxpow_tests::CAuxPowForTest;
+
+public:
+
+  /* Prevent accidental conversion.  */
+  inline explicit CAuxPow (CTransactionRef&& txIn)
+    : coinbaseTx (std::move (txIn))
+  {}
+
+  CAuxPow () = default;
+
+  SERIALIZE_METHODS (CAuxPow, obj)
+  {
+    /* The coinbase Merkle tx' hashBlock field is never actually verified
+       or used in the code for an auxpow (and never was).  The parent block
+       is known anyway directly, so this is also redundant.  By setting the
+       value to zero (for serialising), we make sure that the format is
+       backwards compatible but the data can be compressed.  */
+    uint256 hashBlock;
+
+    /* The index of the parent coinbase tx is always zero.  */
+    int nIndex = 0;
+
+    /* Data from the coinbase transaction as Merkle tx.  */
+    READWRITE (obj.coinbaseTx, hashBlock, obj.vMerkleBranch, nIndex);
+
+    /* Additional data for the auxpow itself.  */
+    READWRITE (obj.vChainMerkleBranch, obj.nChainIndex, obj.parentBlock);
+  }
+
+  /**
+   * Check the auxpow, given the merge-mined block's hash and our chain ID.
+   * Note that this does not verify the actual PoW on the parent block!  It
+   * just confirms that all the merkle branches are valid.
+   * @param hashAuxBlock Hash of the merge-mined block.
+   * @param nChainId The auxpow chain ID of the block to check.
+   * @param params Consensus parameters.
+   * @return True if the auxpow is valid.
+   */
+  bool check (const uint256& hashAuxBlock, int nChainId,
+              const Consensus::Params& params) const;
+
+  /**
+   * Returns the parent block hash.  This is used to validate the PoW.
+   */
+  inline uint256
+  getParentBlockPoWHash() const
+  {
+    return parentBlock.GetPoWHash();
+  }
+
+  /**
+   * Return parent block.  This is only used for the temporary parentblock
+   * auxpow version check.
+   * @return The parent block.
+   */
+  /* FIXME: Remove after the hardfork.  */
+  inline const CPureBlockHeader&
+  getParentBlock () const
+  {
+    return parentBlock;
+  }
+
+  /**
+   * Calculate the expected index in the merkle tree.  This is also used
+   * for the test-suite.
+   * @param nNonce The coinbase's nonce value.
+   * @param nChainId The chain ID.
+   * @param h The merkle block height.
+   * @return The expected index for the aux hash.
+   */
+  static int getExpectedIndex (uint32_t nNonce, int nChainId, unsigned h);
+
+  /**
+   * Constructs a minimal CAuxPow object for the given block header and
+   * returns it.  The caller should make sure to set the auxpow flag on the
+   * header already, since the block hash to which the auxpow commits depends
+   * on that!
+   */
+  static std::unique_ptr<CAuxPow> createAuxPow (const CPureBlockHeader& header);
+
+  /**
+   * Initialises the auxpow of the given block header.  This builds a minimal
+   * auxpow object like createAuxPow and sets it on the block header.  Returns
+   * a reference to the parent header so it can be mined as a follow-up.
+   */
+  static CPureBlockHeader& initAuxPow (CBlockHeader& header);
+
+};
+
+#endif // BITCOIN_AUXPOW_H
diff --git a/src/chain.cpp b/src/chain.cpp
index 7ce0d5df159..7a4ce6b0959 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -5,6 +5,10 @@
 
 #include <chain.h>
 
+// Dogecoin: Include the single function signature we need, to avoid the entire
+// validation.h being pulled in and creating a cyclic include loop
+bool ReadBlockHeaderFromDisk(CBlockHeader& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams, const bool fCheckPOW = true);
+
 /* Moved here from the header, because we need auxpow and the logic
    becomes more involved.  */
 CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams, bool fCheckPOW) const
@@ -13,6 +17,15 @@ CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParam
 
     block.nVersion       = nVersion;
 
+    /* The CBlockIndex object's block header is missing the auxpow.
+       So if this is an auxpow block, read it from disk instead.  We only
+       have to read the actual *header*, not the full block.  */
+    if (block.IsAuxpow())
+    {
+        ReadBlockHeaderFromDisk(block, this, consensusParams, fCheckPOW);
+        return block;
+    }
+
     if (pprev)
         block.hashPrevBlock = pprev->GetBlockHash();
     block.hashMerkleRoot = hashMerkleRoot;
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index c95038d9b4e..b174ccb26c8 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -10,6 +10,19 @@
 #include <crypto/common.h>
 #include <crypto/scrypt.h>
 
+void CBlockHeader::SetAuxpow (std::unique_ptr<CAuxPow> apow)
+{
+    if (apow != nullptr)
+    {
+        auxpow.reset(apow.release());
+        SetAuxpowFlag(true);
+    } else
+    {
+        auxpow.reset();
+        SetAuxpowFlag(false);
+    }
+}
+
 std::string CBlock::ToString() const
 {
     std::stringstream s;
diff --git a/src/primitives/block.h b/src/primitives/block.h
index d41be19ede4..dae194fc417 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -6,11 +6,14 @@
 #ifndef BITCOIN_PRIMITIVES_BLOCK_H
 #define BITCOIN_PRIMITIVES_BLOCK_H
 
+#include <auxpow.h>
 #include <primitives/transaction.h>
 #include <primitives/pureheader.h>
 #include <serialize.h>
 #include <uint256.h>
 
+#include <memory>
+
 /** Nodes collect new transactions into a block, hash them into a hash tree,
  * and scan through nonce values to make the block's hash satisfy proof-of-work
  * requirements.  When they solve the proof-of-work, they broadcast the block
@@ -22,6 +25,9 @@ class CBlockHeader : public CPureBlockHeader
 {
 public:
 
+    // auxpow (if this is a merge-minded block)
+    std::shared_ptr<CAuxPow> auxpow;
+
     CBlockHeader()
     {
         SetNull();
@@ -30,13 +36,29 @@ class CBlockHeader : public CPureBlockHeader
     SERIALIZE_METHODS(CBlockHeader, obj)
     {
         READWRITEAS(CPureBlockHeader, obj);
+
+        if (obj.IsAuxpow())
+        {
+            SER_READ(obj, obj.auxpow = std::make_shared<CAuxPow>());
+            assert(obj.auxpow != nullptr);
+            READWRITE(*obj.auxpow);
+        } else
+        {
+            SER_READ(obj, obj.auxpow.reset());
+        }
     }
 
     void SetNull()
     {
         CPureBlockHeader::SetNull();
+        auxpow.reset();
     }
 
+    /**
+     * Set the block's auxpow (or unset it).  This takes care of updating
+     * the version accordingly.
+     */
+    void SetAuxpow (std::unique_ptr<CAuxPow> apow);
 };
 
 
@@ -82,6 +104,7 @@ class CBlock : public CBlockHeader
         block.nTime          = nTime;
         block.nBits          = nBits;
         block.nNonce         = nNonce;
+        block.auxpow         = auxpow;
         return block;
     }
 
diff --git a/src/rpc/auxpow_miner.cpp b/src/rpc/auxpow_miner.cpp
new file mode 100644
index 00000000000..518736af6aa
--- /dev/null
+++ b/src/rpc/auxpow_miner.cpp
@@ -0,0 +1,154 @@
+// Copyright(c) 2018-2020 Daniel Kraft
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <rpc/auxpow_miner.h>
+
+#include <arith_uint256.h>
+#include <auxpow.h>
+#include <chainparams.h>
+#include <net.h>
+#include <node/context.h>
+#include <rpc/blockchain.h>
+#include <rpc/protocol.h>
+#include <rpc/request.h>
+#include <util/check.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <validation.h>
+
+const CBlock*
+AuxpowMiner::getCurrentBlock(const CTxMemPool& mempool,
+                              const CScript& scriptPubKey, uint256& target) EXCLUSIVE_LOCKS_REQUIRED(cs)
+{
+  AssertLockHeld(cs);
+  const CBlock* pblockCur = nullptr;
+
+  {
+    LOCK(cs_main);
+    CScriptID scriptID(scriptPubKey);
+    auto iter = curBlocks.find(scriptID);
+    if (iter != curBlocks.end())
+      pblockCur = iter->second;
+
+    if (pblockCur == nullptr
+        || pindexPrev != ::ChainActive().Tip()
+        ||(mempool.GetTransactionsUpdated() != txUpdatedLast
+            && GetTime() - startTime > MAX_BLOCK_TEMPLATE_AGE_SECONDS))
+      {
+        if (pindexPrev != ::ChainActive().Tip())
+          {
+            /* Clear old blocks since they're obsolete now.  */
+            blocks.clear();
+            templates.clear();
+            curBlocks.clear();
+          }
+
+        /* Create new block with nonce = 0 and extraNonce = 1.  */
+        std::unique_ptr<CBlockTemplate> newBlock
+            = BlockAssembler(mempool, Params()).CreateNewBlock(scriptPubKey);
+        if (newBlock == nullptr)
+          throw JSONRPCError(RPC_OUT_OF_MEMORY, "out of memory");
+
+        /* Update state only when CreateNewBlock succeeded.  */
+        txUpdatedLast = mempool.GetTransactionsUpdated();
+        pindexPrev = ::ChainActive().Tip();
+        startTime = GetTime();
+
+        /* Finalise it by setting the version and building the merkle root.  */
+        IncrementExtraNonce(&newBlock->block, pindexPrev, extraNonce);
+        newBlock->block.SetAuxpowFlag(true);
+
+        /* Save in our map of constructed blocks.  */
+        pblockCur = &newBlock->block;
+        curBlocks.emplace(scriptID, pblockCur);
+        blocks[pblockCur->GetHash()] = pblockCur;
+        templates.push_back(std::move(newBlock));
+      }
+  }
+
+  /* At this point, pblockCur is always initialised:  If we make it here
+     without creating a new block above, it means that, in particular,
+     pindexPrev == ::ChainActive().Tip().  But for that to happen, we must
+     already have created a pblockCur in a previous call, as pindexPrev is
+     initialised only when pblockCur is.  */
+  CHECK_NONFATAL(pblockCur);
+
+  arith_uint256 arithTarget;
+  bool fNegative, fOverflow;
+  arithTarget.SetCompact(pblockCur->nBits, &fNegative, &fOverflow);
+  if (fNegative || fOverflow || arithTarget == 0)
+    throw std::runtime_error("invalid difficulty bits in block");
+  target = ArithToUint256(arithTarget);
+
+  return pblockCur;
+}
+
+const CBlock*
+AuxpowMiner::lookupSavedBlock(const uint256 hash) const EXCLUSIVE_LOCKS_REQUIRED(cs)
+{
+  AssertLockHeld(cs);
+
+  const auto iter = blocks.find(hash);
+  if (iter == blocks.end())
+    throw JSONRPCError(RPC_INVALID_PARAMETER, "block hash unknown");
+
+  return iter->second;
+}
+
+UniValue
+AuxpowMiner::createAuxBlock(const CTxMemPool& mempool,
+                            const CScript& scriptPubKey)
+{
+  LOCK(cs);
+
+  uint256 target;
+  const CBlock* pblock = getCurrentBlock(mempool, scriptPubKey, target);
+
+  UniValue result(UniValue::VOBJ);
+  result.pushKV("hash", pblock->GetHash().GetHex());
+  result.pushKV("chainid", pblock->GetChainId());
+  result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
+  result.pushKV("coinbasevalue",
+                 static_cast<int64_t>(pblock->vtx[0]->vout[0].nValue));
+  result.pushKV("bits", strprintf("%08x", pblock->nBits));
+  result.pushKV("height", static_cast<int64_t>(pindexPrev->nHeight + 1));
+  result.pushKV("_target", HexStr(target));
+
+  return result;
+}
+
+bool
+AuxpowMiner::submitAuxBlock(ChainstateManager& chainman,
+                            const uint256 hash,
+                            const std::string& auxpowHex) const
+{
+  std::shared_ptr<CBlock> shared_block;
+  {
+    LOCK(cs);
+    const CBlock* pblock = lookupSavedBlock(hash);
+    shared_block = std::make_shared<CBlock>(*pblock);
+  }
+
+  const std::vector<unsigned char> vchAuxPow = ParseHex(auxpowHex);
+  CDataStream ss(vchAuxPow, SER_GETHASH, PROTOCOL_VERSION);
+  std::unique_ptr<CAuxPow> pow(new CAuxPow());
+  ss >> *pow;
+  shared_block->SetAuxpow(std::move(pow));
+  CHECK_NONFATAL(shared_block->GetHash() == hash);
+
+  return chainman.ProcessNewBlock(Params(), shared_block, true, nullptr);
+}
+
+AuxpowMiner&
+AuxpowMiner::get()
+{
+  static AuxpowMiner* instance = nullptr;
+  static RecursiveMutex lock;
+
+  LOCK(lock);
+  if (instance == nullptr)
+    instance = new AuxpowMiner();
+
+  return *instance;
+}
diff --git a/src/rpc/auxpow_miner.h b/src/rpc/auxpow_miner.h
new file mode 100644
index 00000000000..553f89cf856
--- /dev/null
+++ b/src/rpc/auxpow_miner.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2018-2020 Daniel Kraft
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_RPC_AUXPOW_MINER_H
+#define BITCOIN_RPC_AUXPOW_MINER_H
+
+#include <miner.h>
+#include <rpc/request.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <sync.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <univalue.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+/** The maximum time to retain a built block template for, before forcing replacement. */
+// Dogecoin: This is a guesstimate, and may need refinement. Namecoin used 60 seconds (1/10th block interval).
+static const unsigned int MAX_BLOCK_TEMPLATE_AGE_SECONDS = 10;
+
+namespace auxpow_tests
+{
+class AuxpowMinerForTest;
+}
+
+/**
+ * This class holds "global" state used to construct blocks for the auxpow
+ * mining RPCs and the map of already constructed blocks to look them up
+ * in the submitauxblock RPC.
+ *
+ * It is used as a singleton that is initialised during startup, taking the
+ * place of the previously real global and static variables.
+ */
+class AuxpowMiner
+{
+
+private:
+
+  /** The lock used for state in this object.  */
+  mutable RecursiveMutex cs;
+  /** All currently "active" block templates.  */
+  std::vector<std::unique_ptr<CBlockTemplate>> templates;
+  /** Maps block hashes to pointers in vTemplates.  Does not own the memory.  */
+  std::map<uint256, const CBlock*> blocks;
+  /** Maps coinbase script hashes to pointers in vTemplates.  Does not own the memory.  */
+  std::map<CScriptID, const CBlock*> curBlocks;
+
+  /** The current extra nonce for block creation.  */
+  unsigned extraNonce = 0;
+
+  /* Some data about when the current block (pblock) was constructed.  */
+  unsigned txUpdatedLast;
+  const CBlockIndex* pindexPrev = nullptr;
+  uint64_t startTime;
+
+  /**
+   * Constructs a new current block if necessary (checking the current state to
+   * see if "enough changed" for this), and returns a pointer to the block
+   * that should be returned to a miner for working on at the moment.  Also
+   * fills in the difficulty target value.
+   */
+  const CBlock* getCurrentBlock(const CTxMemPool& mempool,
+                                const CScript& scriptPubKey, uint256& target);
+
+  /**
+   * Looks up a previously constructed block by its (hex-encoded) hash.  If the
+   * block is found, it is returned.  Otherwise, a JSONRPCError is thrown.
+   */
+  const CBlock* lookupSavedBlock(const uint256 hash) const;
+
+  friend class auxpow_tests::AuxpowMinerForTest;
+
+public:
+
+  AuxpowMiner () = default;
+
+  /**
+   * Performs the main work for the "createauxblock" RPC:  Construct a new block
+   * to work on with the given address for the block reward and return the
+   * necessary information for the miner to construct an auxpow for it.
+   */
+  UniValue createAuxBlock(const CTxMemPool& mempool,
+                          const CScript& scriptPubKey);
+
+  /**
+   * Performs the main work for the "submitauxblock" RPC:  Look up the block
+   * previously created for the given hash, attach the given auxpow to it
+   * and try to submit it.  Returns true if all was successful and the block
+   * was accepted.
+   */
+  bool submitAuxBlock(ChainstateManager& chainman,
+                      const uint256 hash,
+                      const std::string& auxpowHex) const;
+
+  /**
+   * Returns the singleton instance of AuxpowMiner that is used for RPCs.
+   */
+  static AuxpowMiner& get ();
+
+};
+
+#endif // BITCOIN_RPC_AUXPOW_MINER_H
diff --git a/src/test/auxpow_tests.cpp b/src/test/auxpow_tests.cpp
new file mode 100644
index 00000000000..1176822bdc9
--- /dev/null
+++ b/src/test/auxpow_tests.cpp
@@ -0,0 +1,609 @@
+// Copyright (c) 2014-2020 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <arith_uint256.h>
+#include <auxpow.h>
+#include <chainparams.h>
+#include <coins.h>
+#include <consensus/merkle.h>
+#include <dogecoin.h>
+#include <validation.h>
+#include <pow.h>
+#include <primitives/block.h>
+#include <rpc/auxpow_miner.h>
+#include <script/script.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <uint256.h>
+#include <univalue.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <vector>
+
+/* No space between BOOST_AUTO_TEST_SUITE and '(', so that extraction of
+   the test-suite name works with grep as done in the Makefile.  */
+BOOST_AUTO_TEST_SUITE(auxpow_tests)
+
+/* ************************************************************************** */
+
+/**
+ * Tamper with a uint256 (modify it).
+ * @param num The number to modify.
+ */
+static void
+tamperWith(uint256& num)
+{
+    arith_uint256 modifiable = UintToArith256(num);
+    modifiable += 1;
+    num = ArithToUint256(modifiable);
+}
+
+/**
+ * Helper class that is friend to CAuxPow and makes the internals accessible
+ * to the test code.
+ */
+class CAuxPowForTest : public CAuxPow
+{
+
+public:
+
+  explicit inline CAuxPowForTest (CTransactionRef txIn)
+    : CAuxPow (std::move (txIn))
+  {}
+
+  using CAuxPow::coinbaseTx;
+  using CAuxPow::vMerkleBranch;
+  using CAuxPow::vChainMerkleBranch;
+  using CAuxPow::nChainIndex;
+  using CAuxPow::parentBlock;
+
+  using CAuxPow::CheckMerkleBranch;
+
+};
+
+/**
+ * Utility class to construct auxpow's and manipulate them.  This is used
+ * to simulate various scenarios.
+ */
+class CAuxpowBuilder
+{
+public:
+
+    /** The parent block (with coinbase, not just header).  */
+    CBlock parentBlock;
+
+    /** The auxpow's merkle branch (connecting it to the coinbase).  */
+    std::vector<uint256> auxpowChainMerkleBranch;
+    /** The auxpow's merkle tree index.  */
+    int auxpowChainIndex;
+
+    /**
+    * Initialise everything.
+    * @param baseVersion The parent block's base version to use.
+    * @param chainId The parent block's chain ID to use.
+    */
+    CAuxpowBuilder(int baseVersion, int chainId);
+
+    /**
+    * Set the coinbase's script.
+    * @param scr Set it to this script.
+    */
+    void setCoinbase(const CScript& scr);
+
+    /**
+    * Build the auxpow merkle branch.  The member variables will be
+    * set accordingly.  This has to be done before constructing the coinbase
+    * itself (which must contain the root merkle hash).  When we have the
+    * coinbase afterwards, the member variables can be used to initialise
+    * the CAuxPow object from it.
+    * @param hashAux The merge-mined chain's block hash.
+    * @param h Height of the merkle tree to build.
+    * @param index Index to use in the merkle tree.
+    * @return The root hash, with reversed endian.
+    */
+    std::vector<unsigned char> buildAuxpowChain(const uint256& hashAux, unsigned h, int index);
+
+    /**
+    * Build the finished CAuxPow object.  We assume that the auxpowChain
+    * member variables are already set.  We use the passed in transaction
+    * as the base.  It should (probably) be the parent block's coinbase.
+    * @param tx The base tx to use.
+    * @return The constructed CAuxPow object.
+    */
+    CAuxPow get(const CTransactionRef tx) const;
+
+    /**
+    * Build the finished CAuxPow object from the parent block's coinbase.
+    * @return The constructed CAuxPow object.
+    */
+    inline CAuxPow
+    get() const
+    {
+        assert (!parentBlock.vtx.empty());
+        return get(parentBlock.vtx[0]);
+    }
+
+    /**
+    * Returns the finished CAuxPow object and returns it as std::unique_ptr.
+    */
+    inline std::unique_ptr<CAuxPow>
+    getUnique() const
+    {
+        return std::unique_ptr<CAuxPow>(new CAuxPow(get()));
+    }
+
+    /**
+    * Build a data vector to be included in the coinbase.  It consists
+    * of the aux hash, the merkle tree size and the nonce.  Optionally,
+    * the header can be added as well.
+    * @param header Add the header?
+    * @param hashAux The aux merkle root hash.
+    * @param h Height of the merkle tree.
+    * @param nonce The nonce value to use.
+    * @return The constructed data.
+    */
+    static std::vector<unsigned char> buildCoinbaseData(bool header, const std::vector<unsigned char>& auxRoot,
+                                        unsigned h, int nonce);
+
+};
+
+CAuxpowBuilder::CAuxpowBuilder(int baseVersion, int chainId)
+  : auxpowChainIndex(-1)
+{
+  parentBlock.SetBaseVersion(baseVersion, chainId);
+}
+
+void
+CAuxpowBuilder::setCoinbase(const CScript& scr)
+{
+    CMutableTransaction mtx;
+    mtx.vin.resize (1);
+    mtx.vin[0].prevout.SetNull ();
+    mtx.vin[0].scriptSig = scr;
+
+    parentBlock.vtx.clear();
+    parentBlock.vtx.push_back(MakeTransactionRef (std::move (mtx)));
+    parentBlock.hashMerkleRoot = BlockMerkleRoot (parentBlock);
+}
+
+std::vector<unsigned char>
+CAuxpowBuilder::buildAuxpowChain(const uint256& hashAux, unsigned h, int index)
+{
+    auxpowChainIndex = index;
+
+    /* Just use "something" for the branch.  Doesn't really matter.  */
+    auxpowChainMerkleBranch.clear();
+    for (unsigned i = 0; i < h; ++i)
+        auxpowChainMerkleBranch.push_back(ArithToUint256 (arith_uint256 (i)));
+
+    const uint256 hash
+        = CAuxPowForTest::CheckMerkleBranch(hashAux, auxpowChainMerkleBranch,
+                                            index);
+
+    std::vector<unsigned char> res = ToByteVector (hash);
+    std::reverse (res.begin (), res.end ());
+
+    return res;
+}
+
+CAuxPow
+CAuxpowBuilder::get(const CTransactionRef tx) const
+{
+  LOCK(cs_main);
+
+  CAuxPowForTest res(tx);
+  res.vMerkleBranch = merkle_tests::BlockMerkleBranch (parentBlock, 0);
+
+  res.vChainMerkleBranch = auxpowChainMerkleBranch;
+  res.nChainIndex = auxpowChainIndex;
+  res.parentBlock = parentBlock;
+
+  return res;
+}
+
+std::vector<unsigned char>
+CAuxpowBuilder::buildCoinbaseData(bool header, const std::vector<unsigned char>& auxRoot,
+                                   unsigned h, int nonce)
+{
+  std::vector<unsigned char> res;
+
+  if (header)
+    res.insert (res.end (),
+                pchMergedMiningHeader,
+                pchMergedMiningHeader + sizeof (pchMergedMiningHeader));
+  res.insert (res.end (), auxRoot.begin (), auxRoot.end ());
+
+  int size = (1 << h);
+  for (int i = 0; i < 4; ++i)
+    {
+      res.insert (res.end (), size & 0xFF);
+      size >>= 8;
+    }
+  for (int i = 0; i < 4; ++i)
+    {
+      res.insert (res.end (), nonce & 0xFF);
+      nonce >>= 8;
+    }
+
+  return res;
+}
+
+/* ************************************************************************** */
+
+BOOST_FIXTURE_TEST_CASE(check_auxpow, BasicTestingSetup)
+{
+    const Consensus::Params& params = Params().GetConsensus();
+    CAuxpowBuilder builder(5, 42);
+    CAuxPow auxpow;
+
+    const uint256 hashAux = ArithToUint256(arith_uint256(12345));
+    const int32_t ourChainId = params.nAuxpowChainId;
+    const unsigned height = 30;
+    const int nonce = 7;
+    int index;
+
+    std::vector<unsigned char> auxRoot, data;
+    CScript scr;
+
+    /* Build a correct auxpow.  The height is the maximally allowed one.  */
+    index = CAuxPow::getExpectedIndex (nonce, ourChainId, height);
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    scr = (CScript () << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder.setCoinbase(scr);
+    BOOST_CHECK(builder.get().check(hashAux, ourChainId, params));
+
+    /* An auxpow without any inputs in the parent coinbase tx should be
+        handled gracefully (and be considered invalid).  */
+    CMutableTransaction mtx(*builder.parentBlock.vtx[0]);
+    mtx.vin.clear();
+    builder.parentBlock.vtx.clear();
+    builder.parentBlock.vtx.push_back(MakeTransactionRef (std::move (mtx)));
+    builder.parentBlock.hashMerkleRoot = BlockMerkleRoot (builder.parentBlock);
+    BOOST_CHECK(!builder.get().check(hashAux, ourChainId, params));
+
+    /* Check that the auxpow is invalid if we change either the aux block's
+        hash or the chain ID.  */
+    uint256 modifiedAux(hashAux);
+    tamperWith (modifiedAux);
+    BOOST_CHECK(!builder.get().check(modifiedAux, ourChainId, params));
+    BOOST_CHECK(!builder.get().check(hashAux, ourChainId + 1, params));
+
+    /* Non-coinbase parent tx should fail.  Note that we can't just copy
+        the coinbase literally, as we have to get a tx with different hash.  */
+    const CTransactionRef oldCoinbase = builder.parentBlock.vtx[0];
+    builder.setCoinbase(scr << 5);
+    builder.parentBlock.vtx.push_back(oldCoinbase);
+    builder.parentBlock.hashMerkleRoot = BlockMerkleRoot (builder.parentBlock);
+    auxpow = builder.get(builder.parentBlock.vtx[0]);
+    BOOST_CHECK(auxpow.check(hashAux, ourChainId, params));
+    auxpow = builder.get(builder.parentBlock.vtx[1]);
+    BOOST_CHECK(!auxpow.check(hashAux, ourChainId, params));
+
+    /* The parent chain can't have the same chain ID.  */
+    CAuxpowBuilder builder2(builder);
+    builder2.parentBlock.SetChainId(100);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.parentBlock.SetChainId(ourChainId);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Disallow too long merkle branches.  */
+    builder2 = builder;
+    index = CAuxPow::getExpectedIndex (nonce, ourChainId, height + 1);
+    auxRoot = builder2.buildAuxpowChain(hashAux, height + 1, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height + 1, nonce);
+    scr = (CScript () << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder2.setCoinbase(scr);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Verify that we compare correctly to the parent block's merkle root.  */
+    builder2 = builder;
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    tamperWith (builder2.parentBlock.hashMerkleRoot);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Build a non-header legacy version and check that it is also accepted.  */
+    builder2 = builder;
+    index = CAuxPow::getExpectedIndex (nonce, ourChainId, height);
+    auxRoot = builder2.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(false, auxRoot, height, nonce);
+    scr = (CScript () << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder2.setCoinbase(scr);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    /* However, various attempts at smuggling two roots in should be detected.  */
+
+    const std::vector<unsigned char> wrongAuxRoot
+        = builder2.buildAuxpowChain(modifiedAux, height, index);
+    std::vector<unsigned char> data2
+        = CAuxpowBuilder::buildCoinbaseData(false, wrongAuxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data << data2);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript () << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data2 = CAuxpowBuilder::buildCoinbaseData(true, wrongAuxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data << data2);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript () << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data << data2);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript () << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data2 = CAuxpowBuilder::buildCoinbaseData(false, wrongAuxRoot,
+                                                height, nonce);
+    builder2.setCoinbase(CScript () << data << data2);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript () << data2 << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    /* Verify that the appended nonce/size values are checked correctly.  */
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    data.pop_back ();
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height - 1, nonce);
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce + 3);
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Put the aux hash in an invalid merkle tree position.  */
+
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index + 1);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript () << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+}
+
+/* ************************************************************************** */
+
+/**
+ * Mine a block (assuming minimal difficulty) that either matches
+ * or doesn't match the difficulty target specified in the block header.
+ * @param block The block to mine (by updating nonce).
+ * @param ok Whether the block should be ok for PoW.
+ * @param nBits Use this as difficulty if specified.
+ */
+static void
+mineBlock(CBlockHeader& block, bool ok, int nBits = -1)
+{
+    if (nBits == -1)
+        nBits = block.nBits;
+
+    arith_uint256 target;
+    target.SetCompact (nBits);
+
+    block.nNonce = 0;
+    while (true)
+        {
+        const bool nowOk = (UintToArith256(block.GetPoWHash()) <= target);
+        if ((ok && nowOk) || (!ok && !nowOk))
+            break;
+
+        ++block.nNonce;
+        }
+
+    if (ok)
+        BOOST_CHECK(CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus()));
+    else
+        BOOST_CHECK(!CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus()));
+}
+
+BOOST_FIXTURE_TEST_CASE(auxpow_pow, BasicTestingSetup)
+{
+  /* Use regtest parameters to allow mining with easy difficulty.  */
+  SelectParams (CBaseChainParams::REGTEST);
+  const Consensus::Params& params = Params ().GetConsensus ();
+
+  const arith_uint256 target = (~arith_uint256 (0) >> 1);
+  CBlockHeader block;
+  block.nBits = target.GetCompact ();
+
+  /* Verify the block version checks.  */
+
+  block.nVersion = 1;
+  mineBlock(block, true);
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+
+  block.nVersion = 3;
+  mineBlock(block, true);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  block.SetBaseVersion (2, params.nAuxpowChainId);
+  mineBlock(block, true);
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+
+  block.SetChainId (params.nAuxpowChainId + 1);
+  mineBlock(block, true);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  /* Check the case when the block does not have auxpow (this is true
+     right now).  */
+
+  block.SetChainId (params.nAuxpowChainId);
+  block.SetAuxpowFlag(true);
+  mineBlock(block, true);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  block.SetAuxpowFlag(false);
+  mineBlock(block, true);
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+  mineBlock(block, false);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  /* ****************************************** */
+  /* Check the case that the block has auxpow.  */
+
+  CAuxpowBuilder builder(5, 42);
+  CAuxPow auxpow;
+  const int32_t ourChainId = params.nAuxpowChainId;
+  const unsigned height = 3;
+  const int nonce = 7;
+  const int index = CAuxPow::getExpectedIndex(nonce, ourChainId, height);
+  std::vector<unsigned char> auxRoot, data;
+
+  /* Valid auxpow, PoW check of parent block.  */
+  block.SetAuxpowFlag(true);
+  auxRoot = builder.buildAuxpowChain(block.GetHash(), height, index);
+  data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+  builder.setCoinbase(CScript () << data);
+  mineBlock(builder.parentBlock, false, block.nBits);
+  block.SetAuxpow(builder.getUnique());
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+  mineBlock(builder.parentBlock, true, block.nBits);
+  block.SetAuxpow(builder.getUnique());
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+
+  /* Mismatch between auxpow being present and block.nVersion.  Note that
+     block.SetAuxpow sets also the version and that we want to ensure
+     that the block hash itself doesn't change due to version changes.
+     This requires some work arounds.  */
+  block.SetAuxpowFlag(false);
+  const uint256 hashAux = block.GetHash();
+  auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+  data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+  builder.setCoinbase(CScript () << data);
+  mineBlock(builder.parentBlock, true, block.nBits);
+  block.SetAuxpow(builder.getUnique());
+  BOOST_CHECK(hashAux != block.GetHash());
+  block.SetAuxpowFlag(false);
+  BOOST_CHECK(hashAux == block.GetHash());
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  /* Modifying the block invalidates the PoW.  */
+  block.SetAuxpowFlag(true);
+  auxRoot = builder.buildAuxpowChain(block.GetHash(), height, index);
+  data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+  builder.setCoinbase(CScript () << data);
+  mineBlock(builder.parentBlock, true, block.nBits);
+  block.SetAuxpow(builder.getUnique());
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+  tamperWith (block.hashMerkleRoot);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+}
+
+/* ************************************************************************** */
+
+/**
+ * Helper class that is friend to AuxpowMiner and makes the tested methods
+ * accessible to the test code.
+ */
+class AuxpowMinerForTest : public AuxpowMiner
+{
+
+public:
+
+  using AuxpowMiner::cs;
+
+  using AuxpowMiner::getCurrentBlock;
+  using AuxpowMiner::lookupSavedBlock;
+
+};
+
+BOOST_FIXTURE_TEST_CASE(auxpow_miner_blockRegeneration, TestChain240Setup)
+{
+    CTxMemPool mempool;
+    AuxpowMinerForTest miner;
+    LOCK (miner.cs);
+
+    /* We use mocktime so that we can control GetTime() as it is used in the
+        logic that determines whether or not to reconstruct a block.  The "base"
+        time is set such that the blocks we have from the fixture are fresh.  */
+    const int64_t baseTime = ::ChainActive().Tip()->GetMedianTimePast () + 1;
+    SetMockTime(baseTime);
+
+    /* Construct a first block.  */
+    CScript scriptPubKey;
+    uint256 target;
+    const CBlock* pblock1 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock1 != nullptr);
+    const uint256 hash1 = pblock1->GetHash();
+
+    /* Verify target computation.  */
+    arith_uint256 expected;
+    expected.SetCompact (pblock1->nBits);
+    BOOST_CHECK(target == ArithToUint256 (expected));
+
+    /* Calling the method again should return the same, cached block a second
+        time (even if we advance the clock, since there are no new
+        transactions).  */
+    SetMockTime(baseTime + 10);
+    const CBlock* pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock == pblock1 && pblock->GetHash() == hash1);
+
+    /* Mine a block, then we should get a new auxpow block constructed.  Note that
+        it can be the same *pointer* if the memory was reused after clearing it,
+        so we can only verify that the hash is different.  */
+    CreateAndProcessBlock({}, scriptPubKey);
+    const CBlock* pblock2 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock2 != nullptr);
+    const uint256 hash2 = pblock2->GetHash();
+    BOOST_CHECK(hash2 != hash1);
+
+    /* Add a new transaction to the mempool.  */
+    TestMemPoolEntryHelper entry;
+    CMutableTransaction mtx;
+    mtx.vout.emplace_back(1234, scriptPubKey);
+    {
+        LOCK(cs_main);
+        LOCK(mempool.cs);
+        mempool.addUnchecked (entry.FromTx (mtx));
+    }
+
+    /* We should still get back the cached block, for now.  */
+    SetMockTime(baseTime + 20);
+    pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock == pblock2);
+    BOOST_CHECK(pblock->GetHash() == hash2);
+
+    /* With time advanced too far, we get a new block.  This time, we should also
+        definitely get a different pointer, as there is no clearing.  The old
+        blocks are freed only after a new tip is found.  */
+    SetMockTime(baseTime + 21);
+    const CBlock* pblock3 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock3 != pblock2);
+    BOOST_CHECK(pblock3->GetHash() != hash2);
+}
+
+BOOST_FIXTURE_TEST_CASE(auxpow_miner_createAndLookupBlock, TestChain240Setup)
+{
+    CTxMemPool mempool;
+    AuxpowMinerForTest miner;
+    LOCK (miner.cs);
+
+    CScript scriptPubKey;
+    uint256 target;
+    const CBlock* pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock != nullptr);
+
+    BOOST_CHECK(miner.lookupSavedBlock(pblock->GetHash()) == pblock);
+}
+
+/* ************************************************************************** */
+
+BOOST_AUTO_TEST_SUITE_END ()
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
index 9bc7cc5dab5..b578da7fd41 100644
--- a/src/test/merkle_tests.cpp
+++ b/src/test/merkle_tests.cpp
@@ -116,7 +116,7 @@ static std::vector<uint256> ComputeMerkleBranch(const std::vector<uint256>& leav
     return ret;
 }
 
-static std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position)
+std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position)
 {
     std::vector<uint256> leaves;
     leaves.resize(block.vtx.size());
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 405a51c9211..db85cc68e38 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -254,3 +254,12 @@ CBlock getBlock13b8a()
     stream >> block;
     return block;
 }
+
+//! equality test
+bool operator==(const Coin &a, const Coin &b) {
+    // Empty Coin objects are always equal.
+    if (a.IsSpent() && b.IsSpent()) return true;
+    return a.fCoinBase == b.fCoinBase &&
+           a.nHeight == b.nHeight &&
+           a.out == b.out;
+}
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 960a52b344d..6521cce1d1d 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -172,4 +172,9 @@ class HasReason
     const std::string m_reason;
 };
 
+/* This is defined in merkle_tests.cpp, but also used by auxpow_tests.cpp.  */
+namespace merkle_tests {
+std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position);
+}
+
 #endif

From 3a5da4f2668f3e945499953ea4c9b3098c0ce077 Mon Sep 17 00:00:00 2001
From: Malta Micael <mmicael@gmail.com>
Date: Thu, 10 Jun 2021 21:50:10 -0400
Subject: [PATCH 2/4] Merge AuxPoW support from Namecore

Changes are as below:

* Wrap CBlockHeader::nVersion into a new class (CBlockVersion).  This allows to take care of interpreting the field into a base version, auxpow flag and the chain ID.
* Update getauxblock.py for new 'generate' RPC call.
* Add 'auxpow' to block JSON.
* Accept auxpow as PoW verification.
* Add unit tests for auxpow verification.
* Add check for memory-layout of CBlockVersion.
* Weaken auxpow chain ID checks for the testnet.
* Allow Params() to overrule when to check the auxpow chain ID and for legacy blocks.  Use this to disable the checks on testnet.
* Split the block header part that is used by auxpow and the "real" block header (that uses auxpow) to resolve the cyclic dependency between the two.
* Differentiate between uint256 and arith_uint256.
* Add missing lock in auxpow_tests.
* Fix REST header check for auxpow headers.
  * Those can be longer, thus take that into account.  Also perform the check actually on an auxpow header.
* Correctly set the coinbase for getauxblock results.
* Call IncrementExtraNonce in getauxblock so that the coinbase is actually initialised with the stuff it should be.  (BIP30 block height and COINBASE_FLAGS.)
* Implement getauxblock plus regression test.
* Turn auxpow test into FIXTURE test.
  * This allows using of the Params() calls.
* Move CMerkleTx code to auxpow.cpp.
  * Otherwise we get linker errors when building without wallet.
* Fix rebase with BIP66.
* Update the code to handle BIP66's nVersion=3.
* Enforce that auxpow parent blocks have no auxpow block version.
  * This is for compatibility with namecoind.  See also https://github.com/namecoin/namecoin/pull/199.
* Move auxpow-related parameters to Consensus::Params.
---
 .travis.yml                                   |   4 +-
 src/Makefile.am                               |   5 +
 src/chain.cpp                                 |   2 +-
 src/chain.h                                   |   4 +-
 src/chainparams.h                             |   3 +
 src/init.cpp                                  |   3 +-
 src/miner.h                                   |   3 +
 src/pow.cpp                                   |  40 ++
 src/pow.h                                     |   8 +
 src/protocol.cpp                              |   1 -
 src/qt/test/wallettests.cpp                   |   2 +-
 src/rpc/blockchain.cpp                        |  41 ++
 src/rpc/mining.cpp                            | 110 +++-
 src/rpc/rawtransaction.cpp                    |   3 +-
 src/rpc/rawtransaction.h                      |  15 +
 src/test/fuzz/chain.cpp                       |   3 +-
 src/validation.cpp                            |   4 +-
 src/wallet/context.h                          |   6 +-
 src/wallet/rpcwallet.cpp                      | 205 ++++++++
 test/functional/auxpow_invalidpow.py          | 100 ++++
 test/functional/auxpow_mining.py              | 206 ++++++++
 test/functional/auxpow_zerohash.py            | 134 +++++
 test/functional/data/rpc_getblockstats.json   | 492 +++++++++---------
 test/functional/interface_rest.py             |  14 +-
 test/functional/rpc_dumptxoutset.py           |   4 +-
 test/functional/test_framework/auxpow.py      | 114 ++++
 .../test_framework/auxpow_testing.py          |  82 +++
 test/functional/test_runner.py                |   7 +
 test/lint/lint-circular-dependencies.sh       |  10 +
 29 files changed, 1352 insertions(+), 273 deletions(-)
 create mode 100644 src/rpc/rawtransaction.h
 create mode 100755 test/functional/auxpow_invalidpow.py
 create mode 100755 test/functional/auxpow_mining.py
 create mode 100755 test/functional/auxpow_zerohash.py
 create mode 100644 test/functional/test_framework/auxpow.py
 create mode 100644 test/functional/test_framework/auxpow_testing.py

diff --git a/.travis.yml b/.travis.yml
index 0b197be7598..6763029af76 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -39,10 +39,10 @@ install:
 before_script:
   # Temporary workaround for https://github.com/bitcoin/bitcoin/issues/16368
   - for i in {1..4}; do echo "$(sleep 500)" ; done &
-  - set -o errexit; source ./ci/test/05_before_script.sh &> "/dev/null"
+  - set -o errexit; source ./ci/test/05_before_script.sh
 script:
   - export CONTINUE=1
-  - if [ $SECONDS -gt 1200 ]; then export CONTINUE=0; fi  # Likely the depends build took very long
+  - if [ $SECONDS -gt 1800 ]; then export CONTINUE=0; fi  # Likely the depends build took very long
   - if [ $TRAVIS_REPO_SLUG = "bitcoin/bitcoin" ]; then export CONTINUE=1; fi  # continue on repos with extended build time (90 minutes)
   - if [ $CONTINUE = "1" ]; then set -o errexit; source ./ci/test/06_script_a.sh; else set +o errexit; echo "$CACHE_ERR_MSG"; false; fi
   - if [[ $SECONDS -gt 50*60-$EXPECTED_TESTS_DURATION_IN_SECONDS ]]; then export CONTINUE=0; fi
diff --git a/src/Makefile.am b/src/Makefile.am
index df7cee91c2b..c38ef0e08ae 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -186,10 +186,12 @@ BITCOIN_CORE_H = \
   random.h \
   randomenv.h \
   reverse_iterator.h \
+  rpc/auxpow_miner.h \
   rpc/blockchain.h \
   rpc/client.h \
   rpc/mining.h \
   rpc/protocol.h \
+  rpc/rawtransaction.h \
   rpc/rawtransaction_util.h \
   rpc/register.h \
   rpc/request.h \
@@ -318,6 +320,7 @@ libbitcoin_server_a_SOURCES = \
   policy/settings.cpp \
   pow.cpp \
   rest.cpp \
+  rpc/auxpow_miner.cpp \
   rpc/blockchain.cpp \
   rpc/mining.cpp \
   rpc/misc.cpp \
@@ -590,8 +593,10 @@ if TARGET_WINDOWS
 dogecoin_daemon_sources += bitcoind-res.rc
 endif
 
+# FIXME: Remove SERVER once we have cleaned up getauxblock.
 dogecoin_bin_ldadd = \
   $(LIBBITCOIN_WALLET) \
+  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_COMMON) \
   $(LIBBITCOIN_UTIL) \
   $(LIBUNIVALUE) \
diff --git a/src/chain.cpp b/src/chain.cpp
index 7a4ce6b0959..f88b79148d4 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -11,7 +11,7 @@ bool ReadBlockHeaderFromDisk(CBlockHeader& block, const CBlockIndex* pindex, con
 
 /* Moved here from the header, because we need auxpow and the logic
    becomes more involved.  */
-CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams, bool fCheckPOW) const
+CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams, const bool fCheckPOW) const
 {
     CBlockHeader block;
 
diff --git a/src/chain.h b/src/chain.h
index 663a8b40824..492ce0dce2c 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -191,7 +191,7 @@ class CBlockIndex
     {
     }
 
-    explicit CBlockIndex(const CBlockHeader& block)
+    explicit CBlockIndex(const CPureBlockHeader& block)
         : nVersion{block.nVersion},
           hashMerkleRoot{block.hashMerkleRoot},
           nTime{block.nTime},
@@ -218,7 +218,7 @@ class CBlockIndex
         return ret;
     }
 
-    CBlockHeader GetBlockHeader(const Consensus::Params& consensusParams, bool fCheckPOW = true) const;
+    CBlockHeader GetBlockHeader(const Consensus::Params& consensusParams, const bool fCheckPOW = true) const;
 
     uint256 GetBlockHash() const
     {
diff --git a/src/chainparams.h b/src/chainparams.h
index d8b25c72204..7f28a6912ca 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -91,6 +91,9 @@ class CChainParams
     const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
     const ChainTxData& TxData() const { return chainTxData; }
+
+    void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout);
+
 protected:
     CChainParams() {}
 
diff --git a/src/init.cpp b/src/init.cpp
index 0838472dc78..31f5ae7d422 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -39,6 +39,7 @@
 #include <policy/settings.h>
 #include <primitives/pureheader.h>
 #include <protocol.h>
+#include <rpc/auxpow_miner.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
@@ -600,7 +601,7 @@ void SetupServerArgs(NodeContext& node)
 
 std::string LicenseInfo()
 {
-    const std::string URL_SOURCE_CODE = "<https://github.com/bitcoin/bitcoin>";
+    const std::string URL_SOURCE_CODE = "<https://github.com/dogecoin/dogecoin>";
 
     return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009, COPYRIGHT_YEAR) + " ") + "\n" +
            "\n" +
diff --git a/src/miner.h b/src/miner.h
index bb7a30b1840..ae123812fd2 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -132,10 +132,12 @@ class BlockAssembler
     // Configuration parameters for the block size
     bool fIncludeWitness;
     unsigned int nBlockMaxWeight;
+    bool fNeedSizeAccounting;
     CFeeRate blockMinFeeRate;
 
     // Information on the current status of the block
     uint64_t nBlockWeight;
+    uint64_t nBlockSize;
     uint64_t nBlockTx;
     uint64_t nBlockSigOpsCost;
     CAmount nFees;
@@ -200,6 +202,7 @@ class BlockAssembler
 /** Modify the extranonce in a block */
 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
+bool ProcessBlockFound(const CBlock* pblock, const CChainParams& chainParams);
 
 /** Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed */
 void RegenerateCommitments(CBlock& block);
diff --git a/src/pow.cpp b/src/pow.cpp
index de8ba9be2fd..442b49942e8 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -5,10 +5,12 @@
 
 #include <pow.h>
 
+#include <auxpow.h>
 #include <arith_uint256.h>
 #include <chain.h>
 #include <dogecoin.h>
 #include <primitives/block.h>
+#include <util/system.h>
 #include <uint256.h>
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
@@ -114,3 +116,41 @@ bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&
 
     return true;
 }
+
+bool CheckAuxPowProofOfWork(const CBlockHeader& block, const Consensus::Params& params)
+{
+    /* Except for legacy blocks with full version 1, ensure that
+       the chain ID is correct.  Legacy blocks are not allowed since
+       the merge-mining start, which is checked in AcceptBlockHeader
+       where the height is known.  */
+    if (!block.IsLegacy() && params.fStrictChainId
+        && block.GetChainId() != params.nAuxpowChainId)
+        return error("%s : block does not have our chain ID"
+                     " (got %d, expected %d, full nVersion %d)",
+                     __func__, block.GetChainId(),
+                     params.nAuxpowChainId, block.nVersion);
+
+    /* If there is no auxpow, just check the block hash.  */
+    if (!block.auxpow) {
+        if (block.IsAuxpow())
+            return error("%s : no auxpow on block with auxpow version",
+                         __func__);
+
+        if (!CheckProofOfWork(block.GetPoWHash(), block.nBits, params))
+            return error("%s : non-AUX proof of work failed", __func__);
+
+        return true;
+    }
+
+    /* We have auxpow.  Check it.  */
+
+    if (!block.IsAuxpow())
+        return error("%s : auxpow on block with non-auxpow version", __func__);
+
+    if (!block.auxpow->check(block.GetHash(), block.GetChainId(), params))
+        return error("%s : AUX POW is not valid", __func__);
+    if (!CheckProofOfWork(block.auxpow->getParentBlockPoWHash(), block.nBits, params))
+        return error("%s : AUX proof of work failed", __func__);
+
+    return true;
+}
diff --git a/src/pow.h b/src/pow.h
index 1d802cd01e4..980f2bc46a2 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -20,4 +20,12 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
 
+/**
+ * Check proof-of-work of a block header, taking auxpow into account.
+ * @param block The block header.
+ * @param params Consensus parameters.
+ * @return True iff the PoW is correct.
+ */
+bool CheckAuxPowProofOfWork(const CBlockHeader& block, const Consensus::Params& params);
+
 #endif // BITCOIN_POW_H
diff --git a/src/protocol.cpp b/src/protocol.cpp
index dc8f795a0cc..55261984c6d 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -134,7 +134,6 @@ bool CMessageHeader::IsCommandValid() const
     return true;
 }
 
-
 ServiceFlags GetDesirableServiceFlags(ServiceFlags services) {
     if ((services & NODE_NETWORK_LIMITED) && g_initial_block_download_completed) {
         return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 9fcfb081ce4..1963639ce51 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -133,7 +133,7 @@ void BumpFee(TransactionView& view, const uint256& txid, bool expectDisabled, st
 //     QT_QPA_PLATFORM=cocoa   src/qt/test/test_bitcoin-qt  # macOS
 void TestGUI(interfaces::Node& node)
 {
-    // Set up wallet and chain with 105 blocks (5 mature blocks for spending).
+    // Set up wallet and chain with 245 blocks (5 mature blocks for spending).
     TestChain240Setup test;
     for (int i = 0; i < 5; ++i) {
         test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 986898196b4..72e7e09749a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -22,6 +22,7 @@
 #include <policy/policy.h>
 #include <policy/rbf.h>
 #include <primitives/transaction.h>
+#include <rpc/rawtransaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
@@ -116,6 +117,43 @@ static int ComputeNextBlockAndDepth(const CBlockIndex* tip, const CBlockIndex* b
     return blockindex == tip ? 1 : -1;
 }
 
+
+UniValue AuxpowToJSON(const CAuxPow& auxpow)
+{
+    UniValue result(UniValue::VOBJ);
+
+    {
+        UniValue tx(UniValue::VOBJ);
+        tx.pushKV("hex", EncodeHexTx(*auxpow.coinbaseTx));
+        TxToJSON(*auxpow.coinbaseTx, auxpow.parentBlock.GetHash(), tx);
+        result.pushKV("tx", tx);
+    }
+
+    // FIXME: We have a compatibility issue where the "index" field is no longer available in 1.21
+    result.pushKV("chainindex", auxpow.nChainIndex);
+
+    {
+        UniValue branch(UniValue::VARR);
+        for (const auto& node : auxpow.vMerkleBranch)
+            branch.push_back(node.GetHex());
+        result.pushKV("merklebranch", branch);
+    }
+
+    {
+        UniValue branch(UniValue::VARR);
+        for (const auto& node : auxpow.vChainMerkleBranch)
+            branch.push_back(node.GetHex());
+        result.pushKV("chainmerklebranch", branch);
+    }
+
+    CDataStream ssParent(SER_NETWORK, PROTOCOL_VERSION);
+    ssParent << auxpow.parentBlock;
+    const std::string strHex = HexStr(ssParent);
+    result.pushKV("parentblock", strHex);
+
+    return result;
+}
+
 UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex)
 {
     // Serialize passed information without accessing chain state of the active chain!
@@ -183,6 +221,9 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", (uint64_t)blockindex->nTx);
 
+    if (block.auxpow)
+        result.pushKV("auxpow", AuxpowToJSON(*block.auxpow));
+
     if (blockindex->pprev)
         result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());
     if (pnext)
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 74e1c469b1b..4d45c9f68e2 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -16,6 +16,7 @@
 #include <node/context.h>
 #include <policy/fees.h>
 #include <pow.h>
+#include <rpc/auxpow_miner.h>
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
 #include <rpc/server.h>
@@ -38,6 +39,8 @@
 
 #include <memory>
 #include <stdint.h>
+#include <string>
+#include <utility>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
@@ -116,19 +119,20 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
 
     CChainParams chainparams(Params());
 
-    while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetPoWHash(), block.nBits, chainparams.GetConsensus()) && !ShutdownRequested()) {
-        ++block.nNonce;
+    auto& miningHeader = CAuxPow::initAuxPow(block);
+    while (max_tries > 0 && miningHeader.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(miningHeader.GetPoWHash(), block.nBits, Params().GetConsensus()) && !ShutdownRequested()) {
+        ++miningHeader.nNonce;
         --max_tries;
     }
     if (max_tries == 0 || ShutdownRequested()) {
         return false;
     }
-    if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
+    if (miningHeader.nNonce == std::numeric_limits<uint32_t>::max()) {
         return true;
     }
 
     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
-    if (!chainman.ProcessNewBlock(chainparams, shared_pblock, true, nullptr)) {
+    if (!chainman.ProcessNewBlock(Params(), shared_pblock, true, nullptr)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
     }
 
@@ -660,7 +664,7 @@ static RPCHelpMan getblocktemplate()
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
 
     NodeContext& node = EnsureNodeContext(request.context);
-    if(!node.connman)
+    if (!node.connman)
         throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
 
     if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
@@ -1209,6 +1213,100 @@ static RPCHelpMan estimaterawfee()
     };
 }
 
+/* ************************************************************************** */
+/* Merge mining.  */
+
+static RPCHelpMan createauxblock()
+{
+    return RPCHelpMan{"createauxblock",
+        "\nCreates a new block and returns information required to"
+        " merge-mine it.\n",
+        {
+            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Payout address for the coinbase transaction"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::STR_HEX, "hash", "hash of the created block"},
+                {RPCResult::Type::NUM, "chainid", "chain ID for this block"},
+                {RPCResult::Type::STR_HEX, "previousblockhash", "hash of the previous block"},
+                {RPCResult::Type::NUM, "coinbasevalue", "value of the block's coinbase"},
+                {RPCResult::Type::STR_HEX, "bits", "compressed target of the block"},
+                {RPCResult::Type::NUM, "height", "height of the block"},
+                {RPCResult::Type::STR_HEX, "_target", "target in reversed byte order, deprecated"},
+            },
+        },
+        RPCExamples{
+          HelpExampleCli("createauxblock", "\"address\"")
+          + HelpExampleRpc("createauxblock", "\"address\"")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+
+    NodeContext& node = EnsureNodeContext(request.context);
+    if (!node.connman)
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+
+    if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+        throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
+
+    if (::ChainstateActive().IsInitialBlockDownload())
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
+
+    // Check coinbase payout address
+    const CTxDestination coinbaseScript
+      = DecodeDestination(request.params[0].get_str());
+    if (!IsValidDestination(coinbaseScript)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                           "Error: Invalid coinbase payout address");
+    }
+    const CScript scriptPubKey = GetScriptForDestination(coinbaseScript);
+    const CTxMemPool& mempool = EnsureMemPool(request.context);
+
+    return AuxpowMiner::get().createAuxBlock(mempool, scriptPubKey);
+},
+    };
+}
+
+static RPCHelpMan submitauxblock()
+{
+    return RPCHelpMan{"submitauxblock",
+        "\nSubmits a solved auxpow for a block that was previously"
+        " created by 'createauxblock'.\n",
+        {
+            {"hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hash of the block to submit"},
+            {"auxpow", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Serialised auxpow found"},
+        },
+        RPCResult{
+            RPCResult::Type::BOOL, "", "whether the submitted block was correct"
+        },
+        RPCExamples{
+            HelpExampleCli("submitauxblock", "\"hash\" \"serialised auxpow\"")
+            + HelpExampleRpc("submitauxblock", "\"hash\" \"serialised auxpow\"")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    NodeContext& node = EnsureNodeContext(request.context);
+    if (!node.connman)
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+
+    if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+        throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
+
+    if (::ChainstateActive().IsInitialBlockDownload())
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
+
+    ChainstateManager& chainman = EnsureChainman(request.context);
+    uint256 hash(ParseHashV(request.params[0], "hash"));
+    return AuxpowMiner::get().submitAuxBlock(chainman,
+                                             hash,
+                                             request.params[1].get_str());
+},
+    };
+}
+
+/* ************************************************************************** */
+
 void RegisterMiningRPCCommands(CRPCTable &t)
 {
 // clang-format off
@@ -1222,6 +1320,8 @@ static const CRPCCommand commands[] =
     { "mining",             "submitblock",            &submitblock,            {"hexdata","dummy"} },
     { "mining",             "submitheader",           &submitheader,           {"hexdata"} },
 
+    { "mining",             "createauxblock",         &createauxblock,         {"address"} },
+    { "mining",             "submitauxblock",         &submitauxblock,         {"hash", "auxpow"} },
 
     { "generating",         "generatetoaddress",      &generatetoaddress,      {"nblocks","address","maxtries"} },
     { "generating",         "generatetodescriptor",   &generatetodescriptor,   {"num_blocks","descriptor","maxtries"} },
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 70f9279b233..46222c47f6d 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -20,6 +20,7 @@
 #include <psbt.h>
 #include <random.h>
 #include <rpc/blockchain.h>
+#include <rpc/rawtransaction.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -41,7 +42,7 @@
 
 #include <univalue.h>
 
-static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
 {
     // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
     //
diff --git a/src/rpc/rawtransaction.h b/src/rpc/rawtransaction.h
new file mode 100644
index 00000000000..941463e3172
--- /dev/null
+++ b/src/rpc/rawtransaction.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_RPC_RAWTRANSACTION_H
+#define BITCOIN_RPC_RAWTRANSACTION_H
+
+class CTransaction;
+class UniValue;
+class uint256;
+
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
+
+#endif // BITCOIN_RPC_RAWTRANSACTION_H
diff --git a/src/test/fuzz/chain.cpp b/src/test/fuzz/chain.cpp
index 47c71850cea..ac889bc7b2e 100644
--- a/src/test/fuzz/chain.cpp
+++ b/src/test/fuzz/chain.cpp
@@ -31,7 +31,8 @@ void test_one_input(const std::vector<uint8_t>& buffer)
     (void)disk_block_index->IsValid();
     (void)disk_block_index->ToString();
 
-    const CBlockHeader block_header = disk_block_index->GetBlockHeader();
+    const Consensus::Params& params = Params().GetConsensus();
+    const CBlockHeader block_header = disk_block_index->GetBlockHeader(params);
     (void)CDiskBlockIndex{*disk_block_index};
     (void)disk_block_index->BuildSkip();
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 3bde2fa8ff0..0571c175cdd 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1166,7 +1166,7 @@ static bool ReadBlockOrHeader(T& block, const FlatFilePos& pos, const Consensus:
     }
 
     // Check the header
-    if (fCheckPOW && !CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams))
+    if (fCheckPOW && !CheckAuxPowProofOfWork(block, consensusParams))
         return error("ReadBlockOrHeader: Errors in block header at %s", pos.ToString());
 
     // Signet only: check block solution
@@ -3363,7 +3363,7 @@ static bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos
 static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
 {
     // Check proof of work matches claimed amount
-    if (fCheckPOW && !CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams))
+    if (fCheckPOW && !CheckAuxPowProofOfWork(block, consensusParams))
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
 
     return true;
diff --git a/src/wallet/context.h b/src/wallet/context.h
index 8e96c893342..de44db3783e 100644
--- a/src/wallet/context.h
+++ b/src/wallet/context.h
@@ -12,6 +12,8 @@ namespace interfaces {
 class Chain;
 } // namespace interfaces
 
+struct NodeContext;
+
 //! WalletContext struct containing references to state shared between CWallet
 //! instances, like the reference to the chain interface, and the list of opened
 //! wallets.
@@ -24,10 +26,8 @@ class Chain;
 //! behavior.
 struct WalletContext {
     interfaces::Chain* chain{nullptr};
-    ArgsManager* args{nullptr};
-
-    //! Dogecoin: getauxwork is a wallet RPC but actually needs the NodeContext.
     NodeContext* nodeContext{nullptr};
+    ArgsManager* args{nullptr};
 
     //! Declare default constructor and destructor that are not inline, so code
     //! instantiating the WalletContext struct doesn't need to #include class
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 37d672ace1d..e6373715738 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -7,6 +7,7 @@
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
+#include <net.h>
 #include <node/context.h>
 #include <optional.h>
 #include <outputtype.h>
@@ -14,12 +15,15 @@
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
+#include <rpc/auxpow_miner.h>
+#include <rpc/blockchain.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
 #include <util/bip32.h>
+#include <util/check.h>
 #include <util/fees.h>
 #include <util/message.h> // For MessageSign()
 #include <util/moneystr.h>
@@ -4527,6 +4531,206 @@ static RPCHelpMan upgradewallet()
     };
 }
 
+namespace
+{
+
+/**
+ * Helper class that keeps track of reserved keys that are used for mining
+ * coinbases.  We also keep track of the block hash(es) that have been
+ * constructed based on the key, so that we can mark it as keep and get a
+ * fresh one when one of those blocks is submitted.
+ */
+class ReservedKeysForMining
+{
+
+private:
+
+  /**
+   * The per-wallet data that we store.
+   */
+  struct PerWallet
+  {
+
+    /**
+     * The current coinbase script.  This has been taken out of the wallet
+     * already (and marked as "keep"), but is reused until a block actually
+     * using it is submitted successfully.
+     */
+    CScript coinbaseScript;
+
+    /** All block hashes (in hex) that are based on the current script.  */
+    std::set<std::string> blockHashes;
+
+    explicit PerWallet (const CScript& scr)
+      : coinbaseScript(scr)
+    {}
+
+    PerWallet (PerWallet&&) = default;
+
+  };
+
+  /**
+   * Data for each wallet that we have.  This is keyed by CWallet::GetName,
+   * which is not perfect; but it will likely work in most cases, and even
+   * when two different wallets are loaded with the same name (after each
+   * other), the worst that can happen is that we mine to an address from
+   * the other wallet.
+   */
+  std::map<std::string, PerWallet> data;
+
+  /** Lock for this instance.  */
+  mutable RecursiveMutex cs;
+
+public:
+
+  ReservedKeysForMining () = default;
+
+  /**
+   * Retrieves the key to use for mining at the moment.
+   */
+  CScript
+  GetCoinbaseScript (CWallet* pwallet)
+  {
+    LOCK2 (cs, pwallet->cs_wallet);
+
+    const auto mit = data.find (pwallet->GetName ());
+    if (mit != data.end ())
+      return mit->second.coinbaseScript;
+
+    ReserveDestination rdest(pwallet, pwallet->m_default_address_type);
+    CTxDestination dest;
+    if (!rdest.GetReservedDestination (dest, false))
+      throw JSONRPCError (RPC_WALLET_KEYPOOL_RAN_OUT,
+                          "Error: Keypool ran out,"
+                          " please call keypoolrefill first");
+    rdest.KeepDestination ();
+
+    const CScript res = GetScriptForDestination (dest);
+    data.emplace (pwallet->GetName (), PerWallet (res));
+    return res;
+  }
+
+  /**
+   * Adds the block hash (given as hex string) of a newly constructed block
+   * to the set of blocks for the current key.
+   */
+  void
+  AddBlockHash (const CWallet* pwallet, const std::string& hashHex)
+  {
+    LOCK (cs);
+
+    const auto mit = data.find (pwallet->GetName ());
+    CHECK_NONFATAL(mit != data.end ());
+    mit->second.blockHashes.insert (hashHex);
+  }
+
+  /**
+   * Marks a block as submitted, releasing the key for it (if any).
+   */
+  void
+  MarkBlockSubmitted (const CWallet* pwallet, const std::string& hashHex)
+  {
+    LOCK (cs);
+
+    const auto mit = data.find (pwallet->GetName ());
+    if (mit == data.end ())
+      return;
+
+    if (mit->second.blockHashes.count (hashHex) > 0)
+      data.erase (mit);
+  }
+
+};
+
+ReservedKeysForMining g_mining_keys;
+
+} // anonymous namespace
+
+static UniValue getauxblock(const JSONRPCRequest& request)
+{
+    /* RPCHelpMan::Check is not applicable here since we have the
+       custom check for exactly zero or two arguments.  */
+    if (request.fHelp
+          || (request.params.size() != 0 && request.params.size() != 2))
+        throw std::runtime_error(
+            RPCHelpMan{"getauxblock",
+                "\nCreate or submits a merge-mined block.\n"
+                "\nWithout arguments, creates a new block and returns information\n"
+                "required to merge-mine it.  With arguments, submits a solved\n"
+                "auxpow for a previously returned block.\n",
+                {
+                    {"hash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "Hash of the block to submit"},
+                    {"auxpow", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "Serialised auxpow found"},
+                },
+                {
+                  RPCResult{"without arguments",
+                      RPCResult::Type::OBJ, "", "",
+                      {
+                          {RPCResult::Type::STR_HEX, "hash", "hash of the created block"},
+                          {RPCResult::Type::NUM, "chainid", "chain ID for this block"},
+                          {RPCResult::Type::STR_HEX, "previousblockhash", "hash of the previous block"},
+                          {RPCResult::Type::NUM, "coinbasevalue", "value of the block's coinbase"},
+                          {RPCResult::Type::STR_HEX, "bits", "compressed target of the block"},
+                          {RPCResult::Type::NUM, "height", "height of the block"},
+                          {RPCResult::Type::STR_HEX, "target", "target in reversed byte order"},
+                      },
+                  },
+                  {"with arguments",
+                      RPCResult::Type::BOOL, "", "whether the submitted block was correct"
+                  },
+                },
+                RPCExamples{
+                    HelpExampleCli("getauxblock", "")
+                    + HelpExampleCli("getauxblock", "\"hash\" \"serialised auxpow\"")
+                    + HelpExampleRpc("getauxblock", "")
+                },
+            }.ToString());
+
+    WalletContext& context = EnsureWalletContext(request.context);
+
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
+    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+        throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");
+    }
+
+    NodeContext& node = *context.nodeContext;
+    if (!node.connman)
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+
+    if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+        throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
+
+    if (::ChainstateActive().IsInitialBlockDownload())
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
+
+    if (request.params.size() == 0)
+    {
+        /* Create a new block */
+        const CScript coinbaseScript = g_mining_keys.GetCoinbaseScript(pwallet);
+        const CTxMemPool& mempool = EnsureMemPool(node);
+        const UniValue res = AuxpowMiner::get().createAuxBlock(mempool, coinbaseScript);
+        g_mining_keys.AddBlockHash(pwallet, res["hash"].get_str());
+        return res;
+    } else {
+        /* Submit a block instead.  */
+        if (request.params.size() != 2) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "getauxblock takes exactly 0 or 2 parameters.");
+        }
+        ChainstateManager& chainman = EnsureChainman(node);
+        uint256 hash(ParseHashV(request.params[0], "hash"));
+
+        const bool fAccepted
+            = AuxpowMiner::get().submitAuxBlock(chainman, hash, request.params[1].get_str());
+        if (fAccepted)
+            g_mining_keys.MarkBlockSubmitted(pwallet, hash.GetHex().c_str());
+
+        return fAccepted;
+    }
+}
+
 RPCHelpMan abortrescan();
 RPCHelpMan dumpprivkey();
 RPCHelpMan importprivkey();
@@ -4558,6 +4762,7 @@ static const CRPCCommand commands[] =
     { "wallet",             "encryptwallet",                    &encryptwallet,                 {"passphrase"} },
     { "wallet",             "getaddressesbylabel",              &getaddressesbylabel,           {"label"} },
     { "wallet",             "getaddressinfo",                   &getaddressinfo,                {"address"} },
+    { "mining",             "getauxblock",                      &getauxblock,                   {"hash", "auxpow"} },
     { "wallet",             "getbalance",                       &getbalance,                    {"dummy","minconf","include_watchonly","avoid_reuse"} },
     { "wallet",             "getnewaddress",                    &getnewaddress,                 {"label","address_type"} },
     { "wallet",             "getrawchangeaddress",              &getrawchangeaddress,           {"address_type"} },
diff --git a/test/functional/auxpow_invalidpow.py b/test/functional/auxpow_invalidpow.py
new file mode 100755
index 00000000000..b7a119f26ec
--- /dev/null
+++ b/test/functional/auxpow_invalidpow.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Tests what happens if we submit a valid block with invalid auxpow.  Obviously
+# the block should not be accepted, but it should also not be marked as
+# permanently invalid.  So resubmitting the same block with a valid auxpow
+# should then work fine.
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.blocktools import (
+  create_block,
+  create_coinbase,
+)
+from test_framework.messages import (
+  CAuxPow,
+  uint256_from_compact,
+)
+from test_framework.p2p import P2PDataStore
+from test_framework.util import (
+  assert_equal,
+  hex_str_to_bytes,
+)
+
+from test_framework.auxpow_testing import computeAuxpow
+
+from io import BytesIO
+
+class AuxpowInvalidPoWTest (BitcoinTestFramework):
+
+  def set_test_params (self):
+    self.num_nodes = 1
+    self.setup_clean_chain = True
+    self.extra_args = [["-whitelist=127.0.0.1"]]
+
+  def run_test (self):
+    node = self.nodes[0]
+    peer = node.add_p2p_connection (P2PDataStore ())
+
+    self.log.info ("Sending block with invalid auxpow over P2P...")
+    tip = node.getbestblockhash ()
+    blk, blkHash = self.createBlock ()
+    blk = self.addAuxpow (blk, blkHash, False)
+    peer.send_blocks_and_test ([blk], node, force_send=True,
+                               success=False, reject_reason="high-hash")
+    assert_equal (node.getbestblockhash (), tip)
+
+    self.log.info ("Sending the same block with valid auxpow...")
+    blk = self.addAuxpow (blk, blkHash, True)
+    peer.send_blocks_and_test ([blk], node, success=True)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+    self.log.info ("Submitting block with invalid auxpow...")
+    tip = node.getbestblockhash ()
+    blk, blkHash = self.createBlock ()
+    blk = self.addAuxpow (blk, blkHash, False)
+    assert_equal (node.submitblock (blk.serialize ().hex ()), "high-hash")
+    assert_equal (node.getbestblockhash (), tip)
+
+    self.log.info ("Submitting block with valid auxpow...")
+    blk = self.addAuxpow (blk, blkHash, True)
+    assert_equal (node.submitblock (blk.serialize ().hex ()), None)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+  def createBlock (self):
+    """
+    Creates a new block that is valid for the current tip.  It is marked as
+    auxpow, but the auxpow is not yet filled in.
+    """
+
+    bestHash = self.nodes[0].getbestblockhash ()
+    bestBlock = self.nodes[0].getblock (bestHash)
+    tip = int (bestHash, 16)
+    height = bestBlock["height"] + 1
+    time = bestBlock["time"] + 1
+
+    block = create_block (tip, create_coinbase (height), time)
+    block.mark_auxpow ()
+    block.rehash ()
+    newHash = "%064x" % block.sha256
+
+    return block, newHash
+
+
+  def addAuxpow (self, block, blkHash, ok):
+    """
+    Fills in the auxpow for the given block message.  It is either
+    chosen to be valid (ok = True) or invalid (ok = False).
+    """
+
+    target = b"%064x" % uint256_from_compact (block.nBits)
+    auxpowHex = computeAuxpow (blkHash, target, ok)
+    block.auxpow = CAuxPow ()
+    block.auxpow.deserialize (BytesIO (hex_str_to_bytes (auxpowHex)))
+
+    return block
+
+if __name__ == '__main__':
+  AuxpowInvalidPoWTest ().main ()
diff --git a/test/functional/auxpow_mining.py b/test/functional/auxpow_mining.py
new file mode 100755
index 00000000000..2478c47db53
--- /dev/null
+++ b/test/functional/auxpow_mining.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# Copyright(c) 2014-2019 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Test the merge-mining RPC interface:
+# getauxblock, createauxblock, submitauxblock
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+  assert_equal,
+  assert_greater_than_or_equal,
+  assert_raises_rpc_error,
+)
+
+from test_framework.auxpow import reverseHex
+from test_framework.auxpow_testing import (
+  computeAuxpow,
+  getCoinbaseAddr,
+  mineAuxpowBlockWithMethods,
+)
+
+from decimal import Decimal
+
+class AuxpowMiningTest(BitcoinTestFramework):
+
+  def set_test_params(self):
+    self.num_nodes = 2
+
+  def add_options(self, parser):
+    parser.add_argument("--segwit", dest="segwit", default=False,
+                         action="store_true",
+                         help="Test behaviour with SegWit active")
+
+  def skip_test_if_missing_module(self):
+    self.skip_if_no_wallet()
+
+  def run_test(self):
+    # Activate segwit if requested.
+    if self.options.segwit:
+      self.nodes[0].generate(500)
+      self.sync_all()
+
+    # Test with getauxblock and createauxblock/submitauxblock.
+    self.test_getauxblock()
+    self.test_create_submit_auxblock()
+
+  def test_common(self, create, submit):
+    """
+    Common test code that is shared between the tests for getauxblock and the
+    createauxblock / submitauxblock method pair.
+    """
+
+    # Verify data that can be found in another way.
+    auxblock = create()
+    assert_equal(auxblock['chainid'], 98)
+    assert_equal(auxblock['height'], self.nodes[0].getblockcount() + 1)
+    assert_equal(auxblock['previousblockhash'],
+                  self.nodes[0].getblockhash(auxblock['height'] - 1))
+
+    # Calling again should give the same block.
+    auxblock2 = create()
+    assert_equal(auxblock2, auxblock)
+
+    # If we receive a new block, the old hash will be replaced.
+    self.sync_all()
+    self.nodes[1].generate(1)
+    self.sync_all()
+    auxblock2 = create()
+    assert auxblock['hash'] != auxblock2['hash']
+    assert_raises_rpc_error(-8, 'block hash unknown', submit,
+                             auxblock['hash'], "x")
+
+    # Invalid format for auxpow.
+    assert_raises_rpc_error(-1, None, submit,
+                             auxblock2['hash'], "x")
+
+    # Invalidate the block again, send a transaction and query for the
+    # auxblock to solve that contains the transaction.
+    self.nodes[0].generate(1)
+    addr = self.nodes[1].getnewaddress()
+    txid = self.nodes[0].sendtoaddress(addr, 1)
+    self.sync_all()
+    assert_equal(self.nodes[1].getrawmempool(), [txid])
+    auxblock = create()
+    target = reverseHex(auxblock['_target'])
+
+    # Cross-check target value with GBT to make explicitly sure that it is
+    # correct(not just implicitly by successfully mining blocks for it
+    # later on).
+    gbt = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
+    assert_equal(target, gbt['target'].encode("ascii"))
+
+    # Compute invalid auxpow.
+    apow = computeAuxpow(auxblock['hash'], target, False)
+    res = submit(auxblock['hash'], apow)
+    assert not res
+
+    # Compute and submit valid auxpow.
+    apow = computeAuxpow(auxblock['hash'], target, True)
+    res = submit(auxblock['hash'], apow)
+    assert res
+
+    # Make sure that the block is indeed accepted.
+    self.sync_all()
+    assert_equal(self.nodes[1].getrawmempool(), [])
+    height = self.nodes[1].getblockcount()
+    assert_equal(height, auxblock['height'])
+    assert_equal(self.nodes[1].getblockhash(height), auxblock['hash'])
+
+    # Call getblock and verify the auxpow field.
+    data = self.nodes[1].getblock(auxblock['hash'])
+    assert 'auxpow' in data
+    auxJson = data['auxpow']
+    assert_equal(auxJson['chainindex'], 0)
+    assert_equal(auxJson['merklebranch'], [])
+    assert_equal(auxJson['chainmerklebranch'], [])
+    assert_equal(auxJson['parentblock'], apow[-160:])
+
+    # Also previous blocks should have 'auxpow', since all blocks(also
+    # those generated by "generate") are merge-mined.
+    oldHash = self.nodes[1].getblockhash(100)
+    data = self.nodes[1].getblock(oldHash)
+    assert 'auxpow' in data
+
+    # Check that it paid correctly to the first node.
+    t = self.nodes[0].listtransactions("*", 1)
+    assert_equal(len(t), 1)
+    t = t[0]
+    assert_equal(t['category'], "immature")
+    assert_equal(t['blockhash'], auxblock['hash'])
+    assert t['generated']
+    assert_greater_than_or_equal(t['amount'], Decimal("1"))
+    assert_equal(t['confirmations'], 1)
+
+    # Verify the coinbase script.  Ensure that it includes the block height
+    # to make the coinbase tx unique.  The expected block height is around
+    # 340, so that the serialisation of the CScriptNum ends in an extra 01.
+    # The vector has length 2, which makes up for 02XX01 as the serialised
+    # height.  Check this. (With segwit, the height is different, so we skip
+    # this for simplicity.)
+    if not self.options.segwit:
+      blk = self.nodes[1].getblock(auxblock['hash'])
+      tx = self.nodes[1].getrawtransaction(blk['tx'][0], True, blk['hash'])
+      coinbase = tx['vin'][0]['coinbase']
+      assert_equal("02%02x01" % (auxblock['height'] % 256), coinbase[0 : 6])
+
+  def test_getauxblock(self):
+    """
+    Test the getauxblock method.
+    """
+
+    create = self.nodes[0].getauxblock
+    submit = self.nodes[0].getauxblock
+    self.test_common(create, submit)
+
+    # Ensure that the payout address is changed from one block to the next.
+    hash1 = mineAuxpowBlockWithMethods(create, submit)
+    hash2 = mineAuxpowBlockWithMethods(create, submit)
+    self.sync_all()
+    addr1 = getCoinbaseAddr(self.nodes[1], hash1)
+    addr2 = getCoinbaseAddr(self.nodes[1], hash2)
+    assert addr1 != addr2
+    info = self.nodes[0].getaddressinfo(addr1)
+    assert info['ismine']
+    info = self.nodes[0].getaddressinfo(addr2)
+    assert info['ismine']
+
+  def test_create_submit_auxblock(self):
+    """
+    Test the createauxblock / submitauxblock method pair.
+    """
+
+    # Check for errors with wrong parameters.
+    assert_raises_rpc_error(-1, None, self.nodes[0].createauxblock)
+    assert_raises_rpc_error(-5, "Invalid coinbase payout address",
+                             self.nodes[0].createauxblock,
+                             "this_an_invalid_address")
+
+    # Fix a coinbase address and construct methods for it.
+    coinbaseAddr = self.nodes[0].getnewaddress()
+
+    def create():
+      return self.nodes[0].createauxblock(coinbaseAddr)
+
+    submit = self.nodes[0].submitauxblock
+
+    # Run common tests.
+    self.test_common(create, submit)
+
+    # Ensure that the payout address is the one which we specify
+    hash1 = mineAuxpowBlockWithMethods(create, submit)
+    hash2 = mineAuxpowBlockWithMethods(create, submit)
+    self.sync_all()
+    addr1 = getCoinbaseAddr(self.nodes[1], hash1)
+    addr2 = getCoinbaseAddr(self.nodes[1], hash2)
+    assert_equal(addr1, coinbaseAddr)
+    assert_equal(addr2, coinbaseAddr)
+
+    # Ensure that different payout addresses will generate different auxblocks
+    auxblock1 = self.nodes[0].createauxblock(self.nodes[0].getnewaddress())
+    auxblock2 = self.nodes[0].createauxblock(self.nodes[0].getnewaddress())
+    assert auxblock1['hash'] != auxblock2['hash']
+
+if __name__ == '__main__':
+  AuxpowMiningTest().main()
diff --git a/test/functional/auxpow_zerohash.py b/test/functional/auxpow_zerohash.py
new file mode 100755
index 00000000000..0325efbece4
--- /dev/null
+++ b/test/functional/auxpow_zerohash.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Tests that the "hashBlock" field of the Merkle coinbase tx in an auxpow
+# is zero'ed when the block is processed/retrieved from a node, and that
+# auxpows with a zero hashBlock are actually accepted just fine.  (This has
+# always been the case, but the test just makes sure this is explicitly
+# tested for the future as well.)
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.blocktools import (
+  create_block,
+  create_coinbase,
+)
+from test_framework.messages import (
+  CAuxPow,
+  CBlock,
+  CInv,
+  msg_getdata,
+  uint256_from_compact,
+)
+from test_framework.p2p import (
+  P2PDataStore,
+  P2PInterface,
+)
+from test_framework.util import (
+  assert_equal,
+  hex_str_to_bytes,
+)
+
+from test_framework.auxpow_testing import computeAuxpow
+
+from io import BytesIO
+
+
+class P2PBlockGetter (P2PInterface):
+  """
+  P2P connection class that allows requesting blocks from a node's P2P
+  connection to verify how they are sent.
+  """
+
+  def on_block (self, msg):
+    self.block = msg.block
+
+  def getBlock (self, blkHash):
+    self.block = None
+    inv = CInv (t=2, h=int (blkHash, 16))
+    self.send_message (msg_getdata (inv=[inv]))
+    self.wait_until (lambda: self.block is not None)
+    return self.block
+
+
+class AuxpowZeroHashTest (BitcoinTestFramework):
+
+  def set_test_params (self):
+    self.num_nodes = 1
+    self.setup_clean_chain = True
+    self.extra_args = [["-whitelist=127.0.0.1"]]
+
+  def run_test (self):
+    node = self.nodes[0]
+    p2pStore = node.add_p2p_connection (P2PDataStore ())
+    p2pGetter = node.add_p2p_connection (P2PBlockGetter ())
+
+    self.log.info ("Adding a block with non-zero hash in the auxpow...")
+    blk, blkHash = self.createBlock ()
+    blk.auxpow.hashBlock = 12345678
+    blkHex = blk.serialize ().hex ()
+    assert_equal (node.submitblock (blkHex), None)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+    self.log.info ("Retrieving block through RPC...")
+    gotHex = node.getblock (blkHash, 0)
+    assert gotHex != blkHex
+    gotBlk = CBlock ()
+    gotBlk.deserialize (BytesIO (hex_str_to_bytes (gotHex)))
+    assert_equal (gotBlk.auxpow.hashBlock, 0)
+
+    self.log.info ("Retrieving block through P2P...")
+    gotBlk = p2pGetter.getBlock (blkHash)
+    assert_equal (gotBlk.auxpow.hashBlock, 0)
+
+    self.log.info ("Sending zero-hash auxpow through RPC...")
+    blk, blkHash = self.createBlock ()
+    blk.auxpow.hashBlock = 0
+    assert_equal (node.submitblock (blk.serialize ().hex ()), None)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+    self.log.info ("Sending zero-hash auxpow through P2P...")
+    blk, blkHash = self.createBlock ()
+    blk.auxpow.hashBlock = 0
+    p2pStore.send_blocks_and_test ([blk], node, success=True)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+    self.log.info ("Sending non-zero nIndex auxpow through RPC...")
+    blk, blkHash = self.createBlock ()
+    blk.auxpow.nIndex = 42
+    assert_equal (node.submitblock (blk.serialize ().hex ()), None)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+    self.log.info ("Sending non-zero nIndex auxpow through P2P...")
+    blk, blkHash = self.createBlock ()
+    blk.auxpow.nIndex = 42
+    p2pStore.send_blocks_and_test ([blk], node, success=True)
+    assert_equal (node.getbestblockhash (), blkHash)
+
+  def createBlock (self):
+    """
+    Creates and mines a new block with auxpow.
+    """
+
+    bestHash = self.nodes[0].getbestblockhash ()
+    bestBlock = self.nodes[0].getblock (bestHash)
+    tip = int (bestHash, 16)
+    height = bestBlock["height"] + 1
+    time = bestBlock["time"] + 1
+
+    block = create_block (tip, create_coinbase (height), time)
+    block.mark_auxpow ()
+    block.rehash ()
+    newHash = "%064x" % block.sha256
+
+    target = b"%064x" % uint256_from_compact (block.nBits)
+    auxpowHex = computeAuxpow (newHash, target, True)
+    block.auxpow = CAuxPow ()
+    block.auxpow.deserialize (BytesIO (hex_str_to_bytes (auxpowHex)))
+
+    return block, newHash
+
+
+if __name__ == '__main__':
+  AuxpowZeroHashTest ().main ()
diff --git a/test/functional/data/rpc_getblockstats.json b/test/functional/data/rpc_getblockstats.json
index d9d05f59fd5..c25bdd2827e 100644
--- a/test/functional/data/rpc_getblockstats.json
+++ b/test/functional/data/rpc_getblockstats.json
@@ -1,249 +1,249 @@
 {
   "blocks": [
     "010000000000000000000000000000000000000000000000000000000000000000000000696ad20e2dd4365c7459b4a4a5af743d5e92c6da3229e6532cd605f6533f2a5bdae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1004ffff001d0104084e696e746f6e646fffffffff010058850c020000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000",
-    "00000020a573e91c1772076c0d40f70e4408c83a31705f296ae6e7629d4adcb5a360213db40e4032e98eaddd01559da7cf829651ce78602c8bed0c8eb96d74d1a7a9db71194ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03510101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204779918008bb4454ae02d253c7e4f3e218a585bde2a296a783310f702d011a5cf75e2cef25e6bc076d1aa0f0927a1a142e6a27e84133bb25243767a6c9886f9a1a4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03520101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020259f718b5beaaf66f3720355e7139f0c040f153dbdf3bbc9108b1715f02f6ecf0c3e3a6176122ff4d6f6a5bdcd38b9b66cf17505bc4a5764f1820051bbcfc0a11a4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03530101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c789af2bc9042089aa93bbba8a2af0ae902a40fee38d9f8eacc4b868e95f87acea57c13f65016434a9cafaecd8410262a0c9a65557e5b069c1d456034245d50f1b4ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03540101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200428bf52098d20b042392a2a729d9f7a52dffedb30fb4223c1a2504546fea65b4860de1b20d1268b2169a91df1d08888503b396f163a668bc674083ae3b289771b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03550101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d7c53493e8aee5afa9916f8cb322d8216c5fa658842e3c0e6c450badf8b24519b61b8499ea18f18c5e6039d1942a79430b0c7bcb1a28ebbe57917d2bd6e48ef31b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03560101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020e37d04fe335598f9b817f1d7a4ab34aefb7548840717d529e9d951e1178b07994843569ef48be310c335511b54a88a0aefd954bcf508c3d7b69d09b236b26cbb1b4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03570101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204fa0775111ac94369947fc0d6cb2fda35be1601ce25b16a059e7f2c5fe7d0c8fcbbc07bc5b1b887061d9e93c0095ef312f8d160751045960ded731cef619ceab1c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03580101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002026ad7aacdba9f377a8485d354b525ffd23fd0c570a136baa3604e57a495c6dc0fd2ecb6a50ffbe5f73645ff49c0bdca05528964f629478481771edbc15025f011c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03590101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ae4142ae532bc2992b83a41cce8667365136c5d56352bddf5d808ba0deca774bc407c1d3209dc8b31226e58e8b616eb378ced2774943c2d5ed3df0154368f2321c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206ad90a192fb8469cef52bb9a73ba00fba7cfef75b93cbc7ad20143e15512deec89cc726c5339dac3d7151037957beb278fef3aca85864f0dca26f76d3657cda81c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020811cb5d47df4bb9967b7e4323d0a63e9ade04e6495afdfcecc43ff9e472aeb7be91b7ca68c31aa6a3d01919cbbb0745b30da63ea585bf3174822e91a07b41ccb1c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002020702df2eda4e94ab64c810713123f1781b2d608ea7196f5be28fd755ed09ea513ea3255fd4726d14bc54aeb09d91de757df2dcafc4fc8c8618a8de904367fcc1c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ca91ca53d3fb7a26a30af9f04404487b25901443bb8f27fe07a0acfd18865c2fabd3aaf05202a7469af1589ac690c9da01641a38ff148ffd8749c7fbe29124791d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b30b222dda1bb6abd4338d4eaa22c99ca41b194e334e5fb80115ff6f4499aa3f8686b394132280553c1bab722522eee155de484e9d07744469c229dfff6862431d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020bb5b72d5ea8afeb01f6ea0f5b245d9f50b9754b1884525142636f2777b6388262c35a1d3464faa96a31b8ee0f21d440d34bf0e78a421d2ae718fbd2d61e4ba9e1d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03600101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000209f499ec3a7177fbbf0a5131329d5a695e9a72b14404f08d1e6f85575f0118bdea43f17a9d7bc9f30db05d6e7f2c1b843188bb23ac6cfa96054001732419955551d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401110101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000205d8ff71f1420372d86c531cdb622c559e6649908b9b3cf192b1d5930073a7896a25dccf782264379b5260d2a6f469f7130b28f891a781cceb5eca24dc6c59d4b1d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401120101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020704e10385cd9c5ea98e813fdb772b5c6b4f488cb5902f774dccd9e12a4cd6d856a2d4126e2119e6dd207b5b6d3aa694ca3d19f22b42ee9ca3af20f97afdfc2811d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401130101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020cbf0dd866808489b66ed68d5e21de703a2905b44ecc488d051ff6c3cfb113a207d0b8626465b7bbe87c3df33ef0dca2cf149ec1376e0d4df65e729d0464d77071e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401140101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201fdc1c77473ec23a7378c273eadac387c61ab9c101c3b367c1e608d75c37cc4695515e244f1bf7d8c89794bb3d16065a376afc274e57edf11c511c512f54fa811e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401150101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020e16981278df1d5a0a5ce59124f82091fc3e93a6f5f2f5d629938ebe6218ed94d7e417dc5ee89ff08491d4c91e8e36cf43e9ae4ddeaad4916e0ffd51debfde63d1e4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401160101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020122a7a8592e232be2b9bb452aef0abb6721195c745f31aacd40302f6ae2d52ddd10a51b038b39075363ae201f1d5acbe7e488e6ae66a604ca2138d8d3cb018d21e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401170101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206cb2082cc75a4f501af1bcf70f567beb6b06a6e7bfa87a7fcfcaad3fd6803b02e36a79bc1c476ce697880daf8155c8a3375b8eb35b41cc88b70181a8c850a2c81e4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401180101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020a21254a6a0eb6c65c062f5a8cc16a1fbef23e3ec331708093ddf3b8b4b6169b84625359f4ea22f53c76bb6defc9f41363eb513ed4acd24b71ee59c08b0b183bf1e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401190101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200dba11f993e98ea720cfdda0816dcbe2282e2d05a4db1aaa935bd751a9ef204a2ac4a8ed93f07f39d81dd4e8a55b541bc1c9b2d517b247314680217fdb0068351f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002051e1cada1b32f0a3545ccba7e90ab44fa1668cc35a40952c1351c86626673a702bfe715dc17738598b0693f53fe8c52c92889d6d7d138e2faa8b339f4ec7d4531f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b0b234d6373880fc435127b9bb1c23a8fecd7096f3aebf78c950a5cfd5898be89efe85cfb8fb03e1baeac0969cf5d96094205bc6a3845c601804e7a1927ca5c51f4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207abc9dd564e3a17dca33e0bdbe7b46ef20a7ece4a9cf2e7b26710b71ffd871abb591d3074309b5da323ac615023f08bf7cce6b49db7715826899a8b5339eec4f1f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002097d2cdece29a2c82439a44dee5385f1df125d67923f84edda5fef212532406af0efdb9d5fd7a876a84bb3ad26ebd3f3c61bdd2b43ddcf0b9deb3ae6e1b3c77051f4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002087b9f2e2e16c4975f1289e924fb7fe119796692f742f8b56af3134aa2939ae24128b2ce073e54cf3d7d909470d88636c91711a8ca096839222de396f0798b24f1f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201d103e8f262310e1b2e57604961832ea71cbc61d2d40341dfe062f786832fc946f25d446568286f8eacf14b8152b71d7bde97d15f945ee3997a4e96f24920854204ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401200101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000202985b43f556ac33253b0af311a7134e1ed9fc63ba34f09cd3c55fcc19c064cc306278787e885912c1fe9b08b55697d19a2098c30b8019b2590de4f4ec33185de204ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401210101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203b2e8e6cb988c98e5b88f384626d33cba1566bc034096caac9508406081a3527607d707501e94defcf7b00a1c07b63f861ec2b2b10ae22377aecfbe56ab5c838204ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401220101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002014c3edbc1895e44bd5ec9f943827afdb9fe5e940620aec6e0745eb322c847586e92be068c75e4aea718a96e7debc930169f0da2e12e82c542c23e11a7597d763204ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401230101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d59e858dc049ad99edca0c1eb8547ac8ac785e90ca80c6c068bca0ddd872375051e3cb0877e932083c1ed1fbfe0b2a80a11b539e7726c943a45a59c4e200be90204ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401240101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204c1556e51b65ad1a7e08cce9e43ac4055deeac54faecc55e273ef67518861080c35d7a1a3ca59328aa2a574bebea8d0e964485290db4f448e832f812bf843d56204ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401250101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020bac91a2e11aaf91d679df928c3845bd60d04f13c7f586cd0f2bc78ada191c4b984b9dfa3cce5d627c889a487df9a7857ce4eaab9a5f876f33302a198aba62f5e214ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401260101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020084b4468ba2eaa77f9d3a475c25f0706b4a93804d6d00cea9f2cdf360a835350cf1678e36d905b9932cc68b581aa8f5058492ef554d7c40550efe86b0d7b57af214ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401270101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002082024b72b26b53789062f01ec31f6332d0bf243042dded1d64a756d1cb38195a9a0a742b3aa4e9a09bade628984fbded4ca4fdeb3546e4b0650d2712caea7fb5214ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401280101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206a3863cd0b9e745e923d36be540f42b265bd618c6d98b9b95e86c4a03d8c7fb6fbeb6f108215a05ed342165e9f78cafb71c519ea5495c608756c346d7396a244214ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401290101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020823c30af55a57c3c29c62013a79e5d4e1257c2035775c85921082ad1d61a2f3d93e680e1aeade31f4c41024af841bb4342ac9263831a8bb60b49118b99c82b69214ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020106182035be1e8dc255924d9117feb786827c2d697fb57cdf951494dd3899185f2e479371803409658f07d1226ebb853f26052bf2c32c772600f9f9f095d89e7214ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ff2490cb4d0dd92e9626778bc33853fd64759d7b7453dd5d67231addb16936cb82c31483dac7f3e29abc8ec8b9a44dee570d30bb0bbb919b3daeff4f2bc13371224ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203a89c3f076cc6c7bce2d86b727bf1d5c4f896036558cd36e8c39c6497680103305af0434465560abea118d2b0be44fffe70f031eafa432d518ae24c1f04dadd5224ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002063ef350804aed49ed023287b4414e8fdaccaba6ebf78247a230ae8316e22fe8becc5344c2b300d49b595c67891a663566b4c9ffdc9afa13029a26335ed25c457224ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c7890a799ab18ef0c0e6907b837085b02bfd531cd53b0b6510dc19ca286a6dc52dae27037072caf5fa97c166bea89df60cfadbd116f9ecaafe453aaa230532ef224ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c48e425948b7cc8ec626e29b6fa9a7a4a382b900fc13711abd674b96a9b6e181d3ea2c2ea321a720b1774ff6b57da9f74e259edfabd6b889c83f7619ce916938224ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401300101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f87e4927d962e884399484d63c62ec3378945fd4f683e91f23d776be21e381ea63bbb0b67dcb1f83215eab58279f49517a3b2f7f3e93533a88d99788020cb99d224ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401310101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020648d542ca6389d3da49195467d20e67dc9b1d4c584bdb8316385c6f5bee50a49803a85dc54fbf2a041dbc2cdffb33b15913c644155e8d297007cb809040c94e7234ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401320101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002044738f5769b42017180d34a701fe87997c1b55f903542894d25862028a8e1172aa0616f42a608ad43a421e758231a21216b0b366f2d50bd4fd98a7a1e0b5aee7234ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401330101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201ba797d62b90988e63ee915be729abd263ff4478b7cad84d35dcb0abc19891f65237ca5189d4aa4385b29035457a9e1c8b2463512f3881889370dfc0cb9f5813234ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401340101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000205c753889a425a160b2c5902c1220ed3b9b5f75b81601b71f3e6a4f20c0c3f127a4e483bfe855a0a0903afc50ea72fe551fccc3bfbfa33eabd61fed1abe75e721234ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401350101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203a66d25d5d4fbe95450fa38341c1a63e9b1accdb2f893acb6dc893a9746d1454647f06f82b76dea8e3b81acc164cb2e5ccc64f78cf191b28ed313225cb38cfaf234ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401360101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002094e6047d2f091473761513f48e03364fe9f2a50fbf8d656cba6bad43cea4572a0cf088861245b3d3d16453a8ac34ded5336542c5699cf7b5c55f89fb107c7f7d234ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401370101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020da9686353dce5f7d048f4e1892a41454a9dbedaec002d41c82506524e26bc74e8df1a30ade3e06eb1e9b289d1e0b9d79debd88b8b32022e41ae889008b873963244ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401380101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020def98e3abb5a919b0839574a3bdeb798fb0e58af73610940b6f8bb963c42e0be474b4eacb7d3309d45e889b7d65f4824a05adc3f5425e95d3725bf7fd35e44cb244ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401390101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c7ab8942c9985e92bba5efbfebf6560e144af7f8bad750fbc369c848a2e8f310cb19d5db44e188c0301ae2de87e57f9df0a5a0a10f25c4dce1bcfd84e451dfeb244ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002083fe827c61f481b9f7d5aed70ac9fbffce4e2009ee90f86e240cc3d462809213f312690ad49ca5336fa2cc39a3dbeafe8ffc618b9c1de26375972212e7bc9544244ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d2580b1ae6e6466aa328c46134631c02912b2d0f591fb7ea07088380182c7a1928484a4310594dbc1f2b0cd5174bab0cacc202299e2414719dac17bba002cdef244ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206f77f430550816d867612663efca38df2a7dc5bbb5ff09b2d680e367fe2a17e93b0ef6d4726a2fd8910aac05b388bb52f91b9bfda18f3e34e45f3cf8758f4418244ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f02524463ff092c31e5461e512ae9b4d5580808230a41171af83210dbf581822fd569603f075b948566c403f27c9e7131b97cbe12d8f0a86bf359f8c661c1056254ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203b40d1d2231413e9dde80d7959fb1dc62a201a8805578f796f1e4f5bbc8d3b5f1779cb660c8142a8fa66f4f2b227e5558f13e2882ad1c8c87c422fd9dab71eea254ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002016e8650be8df609c9708909227b31f0b45138c670b2c284ee518daf6e3294eb0f603da762ca3e32f7812a848d8d0ac66f54395db3eee8953d25a796a77bce05d254ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401400101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002029e7eb3606763926ae24c83aaf56a73c9cef7e31d8cb4c106f7ff5a7a5e6a53eb607d59ddc5648b983a9279d31a74313ad8db8497e90c95381d02adce5613b9a254ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401410101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c6271be337177375783fc0307965343999a7ad5a2c088b237514353e94f9cd5321d462160ba940356a52bb4014b167ca6c491ecdad7c2789851703b3d4188847254ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401420101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206e5c449b5ee1b33afd5619c587b57d28640c16c45377b00e1f4c0507f6248169e90e17bbab10f8e1af8d10029a84ee2a971472e540ba27efa14664847d7bfd96254ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401430101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020acc182950c0b7768ea184716c26d7814d317052f387bf2d5e6e824a10b2e16643e25ef3dd966dc85197a48918800df6c792828a6b649253eccbb90a9fe1381bc264ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401440101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ac20924ae7b07d461551e29986739c7c3c04e555b6ce46fefe024c47be8f380532076515b4946271b4d30bc59ef8d4ea4451147eae091e5f38c73887205828e2264ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401450101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002074b91766f0b8ecef4cfafc315c62eca3ff533498f42b37c90f891a2a1af2ad8b9f2d4a03373ab2f6bece4e9fc108c540f6f1fd3133246982654c60cf65e57d3f264ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401460101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f28c76473491170e1e7f467b8187bda9250e2b5c1c468692a2d731ec7c823adbe488002bbf188f8560b05806f443c7d3c876f589ebfb26cbe06d1bc400dcb354264ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401470101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b441d88f984f9bc18a04d1a5ad1bff450ea810d4e758e2fc3a75479283e75bc25cead78faa4c4de5aaf1af45847042328aa948b9d40f6db59a0d28c2fddb5572264ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401480101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020234d84ca651cf59608edfc0dec69b9f76d947236311ef11069f2cbd77e950f9808547c332f5ece4ac74b9184ddec493918932f551d0a806bddf69736f562341e264ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401490101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206e0af41c63ce5dc5f59bf12c306a1e34560a3df404c15f8e5be13aa3bbb00c74df56d380deff815e91760a599bb322d5e2895595b0b7891ad4f604c1413a2815274ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002047f27b82ff58938bc6ae617d41d42c8434a15fe21c77063c3ab918588858218593da92685cc7d12fc387bb8f742463321c5d64a6a94a557da83bb9b615f5c3a5274ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200d7f759753a48ed3e0983ee971db7445694562d4f11f34880a53ecb700601c83a7f555a5dbfe331035ca85ef4e1687848ec6b7fee5e3d11a4c881fe2fa7c29f4274ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ae6c6597d96e3beb627c0a40f2eaf32e437fb41143c0fbbcb59396775bee8558eb44a480c641c2a3b090cffdc54e36f4a2fcdd66a600b6371271fcc446ae39f3274ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ec7a711185adca7dbcb504b12cf9c6a6aff0e0e65ac2a35a2b7014d556b3011420db43df1a4ac71c25a63c294813fa0217414d5dbbdda98babb9a0698b861724274ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207e7ae25e948d98b93a75106109f198ab89b7fc3ee2cd2765394dfaea7e39f16be747b039403939b657d36e7ac59d5467b2520d02addb0014292a4892105d198e274ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200974ab0c3134b5865f4fb016fbf3fdaa0beea89726a6034f31cce5dff086052d7371b37a7deea0d85aba44226d29b411eeb20e9dabf0c74b767e61a7b413acd5284ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401500101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f232bc773c1fc07d35739436651f184a9f7dc60f5cc32f3ca39c8527fba3d27a5ba82a108d691667e6506c11cc652c6628a355b8818df5a919c4bd67d2de0a45284ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401510101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ab2c3ca90bc347678ed98227f95fba895db233d770f039c14d759165f534d67725a15d14bd25e27a4cb3ba7a2ee148f21e9574dea908ecc1a057372bea5d9fa5284ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401520101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207bf9247557ad358e0e0f0e1d8629e8064d4f636b0a5cc951bb8a000af8945a2fd07c793a0dbcebbcab30d3a4d4efac18b9f1538d77ba8e326b14c82ed261cf32284ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401530101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203355aa9969b51c809a54aceaa7431eb5891ce448953549951ec5d8e83c55cc689eb9470d94f10e6fe67d170c066208a6aa73b25c84eef366f7533acde32f5798284ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401540101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d4620a8867f251d92be59a7a67ef61c37ae98455d07b669df2733b683e27e5aa1b67caf16926291b24f219b8c579734c78f36e582b5805f799be5aadf3d7e38b284ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401550101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201a3c00ba459716dd126a18431355690ea9b21491693dad578a85cea9a7b6a8bc45b76a1790cfe1334bc6ebaf94aa72494da9504b76edd0a7654f8c359086d666294ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401560101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002060d3170b9b8b77cf6f2ff9936fcd3098512fa6f07adb1794222927b3cd3ba95b452418d8708fe47265ad57981f12ece0e586fe847be239278eb470d0dcaa019b294ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401570101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d752502170caad104e920852c134dd91ba934e6cae48d68f7b88246abc585900292a893996d465dbaf56a6bb3462bc16f4a59c3f5072c8b4ec90fcdbdbab9dc2294ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401580101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002038dc0c654b45e07f5e01d0602773ff5e33bbd181bc4e04f603baf184138408de88d0966cea8f2440953abfd723c212f62735f9034d10684f2a04c0e76ec08f10294ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401590101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000202b81245e8b003bf256764efa330435f71645a43e13f41603f79b953f0bf93a07b4fa7f3266d560c5783ca20431b298c90c3b3c236215f9a4bca120b034a51d96294ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020027255f3725c24034f81d47323c8bd26019230399278e05a02d8513febbfe8ccc2c53cbc4dbcb5e88353fc6553c3cea509297a47b811c52034b85bb41dca4275294ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206bc648636039f9614d92d01749f2a5bb2093eb45bb2bd5b5d1b128ce07cc954594f6df10c90e7a8d7fb0de04a495328d7ee90a6aa5d40f1192e92f03cedc58902a4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020e1d49fe0ef814a622b7ec1ad8d472c137a176a1f6f97788d97c5dce51aa1824064a3a926d8e2b5d3de9d4fc5acf25712c585ccf1ca986185b4ae570df2aa259b2a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204630ed2534bf4fd1a7a1342c5c31c0735502c1a33e290b494731a208c023bd0d94b0bd8b419a4311fdcde709ed54525956d652f1c7a0049da4df36bdb9f524aa2a4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c7004cf7dee4b0bc627be63359eb03a54b0a62b89d0af6a7501e3cf28126c576ec00071519a45cdc8ef5bbf109ceca3bfd85594ac6a0aed34a95f0f838a4c6182a4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020e3fa004d2589eb421a016b732a0d6c143a848a1c8bedf167048eb769b0fa82248aae6cbd53b2a43fce81a9e0e880e6898d44553147c54a5abd7dc5228d2274ed2a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401600101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ac929a0699be46f5aa9b3f6882dc4e9a0d47a88121b7e6be10d8099c8c5563a85707cbdbcad1f56abed1d202b9dfb9c7984290de1b05efae2df45d0e50e2752f2a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401610101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c156b0bca85a63c26a0dced8da84cb14c42a5d20279e59c3b756488e4b94882bda1dd7555778cb4f24141d34def48c1a6e43cea0f3784a21e7b367e42a09cbd32b4ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401620101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206598cfb9e662a96c5c19541b16ec6596fa8db3b3d975daf83b5f8353acf0b1f05f7dafa529c7472d47b32de80fd454cb5117f3f6dce5c14c25b6948b5d66de7c2b4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401630101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204d19cef8be460f962d424df87b0b4ef731cdbae86f79dab11e1f9da6fbd385a0a0b7a234a1eeebafdfdedca088a40034f0ae91586e254ef175f41d93292dfc002b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401640101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203dcb8ab1babce5ed56e21b307e5083e95cc4af17199491fde01a05f68d695899fc48ca3ddb6c183e3deb4f4c8c56bcb83f9aabbcd4bd9a189a76c01da50cbc722b4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401650101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020fc6640151c6c96175f52bbca3900da62a62c5295605a54e26b7c0193dd695769dae04c86109e15e1c655d97edcb3029b3260c1af6a59f4488c865b27feb4e6ee2b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401660101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208b256b9ab6870f3a05d4066bc2fc58a67b8fff2f81a11fea35ec0752ba3ec649f534e65eccb9bfbc1e7cb56e25e6cdcc8ff966516249635fb17dbd89813ffa042b4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401670101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020588d6f4ba43b556cd7a07eeadfdb77706390c182aacbcab4b96032d8c67906766030d1e7053a8aabe2c8fe44bec4df0ad4ec6130467899f90aefc9d43bb80f962c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401680101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002000df91ecfabfffc99d37a117bef69da8c78a41819023331cdb16242faf26e4412696fa30728552bdb615d5c3f6c2bf1249a9e199e4362aae88064806349a36602c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401690101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207282e0a9eb71caa53b762ca85d5fde29f764dfe3dfb386d3885868a4b0b187a558e3643d5cb560d8a97af5bf6c733ddb1e1766f280c1db2dc6b52ed3ae04aac72c4ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002068fbd5b6f63225c7507053d5e4c2c5f4df36f7dcc56fc78dcb3c459afd13d29daa13649f1218e4aef9317b876e4152bbbfa42e874167c8248708e3fc50163f772c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206ae32f5a23a359f8236c408aee3a3362f19df3b0f0103a78d4d88db7888fca88df34890a7439a2f0ea002394e04c7925e8e40edc76ac7711754b45a30c5b5c972c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c6be91db695c38570d23a8d839140fc8c74047e23397eba8712334809e00d0b0f6b48e5948d891103d477a4ac55f7ca7cf3b04cebbd4bc1a6706a1b87b14817d2c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020477cbb127eb2533b50b98a7ca7ff43f7c3eab4def18bfc58d610c0d9494de4702a884520dd628e04a57bd6f90c9639dc0da180aa5d888fad779c3311b3a654602d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000205bc291fc840e9ca5cf81abb270278913aa60e88859b53f1faec81fc969f53ad29acf192cac6b33d9bc53a123b8b8403d1efcb8bed0470cbab3648aa6b31e957b2d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020abbf282afac89287cda920ec9513f68ec3a55666b0f17c12fb1e44bfe0b37db4393c68fbbf7d4cfd4e4c1c194f75d0ea803dfd43a197869e704394e3186a9d452d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401700101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200980edc9ee622a5cf3577ece741f66ca71b363752bcda8b3ce8dd2c1131a15f325282b876a5e2cccae63c8ee5273c7e609249c93a77651b56ceda6c3705004502d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401710101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b5b967909abda65f58506d9db559f55bb9615697d1e4c256877445ac0d1ddd8cbaff6cf10091f1fadbf7c68e9b39c1f0b674d85641984241745e97ae6df409a92d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401720101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200f4304a3ae48166eb084abf7c7f68884d307277829926b9cb43c0655c365e85fb4dab36d5f3828645d3b3279261ffe931b47a1bbd14d22aa59ece3e6cf0f43992d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401730101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020eb1bd3894bb810b7eebb50d52d12bbd6ef11763d7beddfcc7510dd0c9aa4aa427ad08fa3a63aa359ed7c2596382d926a0de61c1d2e346739c5d4b3ff944918222e4ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401740101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f6e85468a2ec48482dac7b95986b54b2e2da766db6c545e632f2a619c09879631ed9fe8bc6b228aa3300a00573273848dd170b1c07770d83f56d5e2696aeaa8e2e4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401750101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002073b1f5c7c921acff83505a0e05b48af40d4d8dab9384ed46ee56abfd922d0804c031d30e38077c849412ecb96000fbabcaf0949ca4c7252f2bea8b50f0d755ed2e4ae75affff7f200700000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401760101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002056b26ed4d0f5ff9b1800d0f4f092ddbe27e95908e8d50fc442abc60942114de7fafe9aac9b83ed83504b9f36a45d9e7363f160d28740b66b5747ed1ccd712d1b2e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401770101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f3e884463d720267d67681ede8718d7a92687f0b6ebe13ecef7f34ef5ebca65e24bfdfcad86ac46dd219701ef0ebf4c7b94573941149a82a34145ae2aa03be092e4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401780101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000202faebb431b3b209f7b94fc0524eff0e03667eea44b1c45b30d67f671614aa6b17a9c63fd2ef583d1f94b2b489074cac8c16de8292a3ef8b11e170de2859656a72e4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401790101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020038be7f5b01d1924057820362779c175989c9efa13c9c14746f69d4848525ca342c2b2f25a0f8df8296ff0f4f5cfa4b9488ef17917e01b6e4bdc2c96e7b8864c2f4ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002003bf2d6c7ca04b70b2545473e3dbc437289c90faf5690bfaeac39170305c99f87ff22f538cf08a527f39f015bc380fd890bef5f066e2f86fe150c442eb069b4d2f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020fa7d81a684870f55aa26ae51a935b2da2882af161a8deb08331ee2000466afbe94f77126b8a8600d6a5eb58b817b18a1ede25a8ab38f26b9ddb8f653fe0628e52f4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020eb3d67d4c8654b4a837a7ee2dbcc5561f1fcb57a58a819e17c4841ef9f0e851c8f7fc3bfcf363e3ce275268f714a463e9161a8f7d9d770279c289b34b4ae5a792f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020868b83f09ceb1ff84689c608da11fb93ba8c71a14ac89ba274277a39f616b28f206d3ed0c8970241bd417e0525604adba077e1cf5cc22f251ea8f0cee6303d092f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200e2f44c66a95c1ed68f1ad84577971e6fa03c48296aff607d19c8275807781d5226116b282507e43d3fff4eb78629f9a5d07920ed45a30e414c95d611d3a83c62f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208c4f07cdeb4e7269de2a7e7f305f363ff43fcf867ad0749374289f9fd079f56054afbcd2a6842515ed26522d2c100c4b3d8f98aee64bd8eb219f50504b3640ba304ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050280000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d828fbb483c792800ec9933ce34fe9558155853eed48e54bd4371d3e124431ca976441b7883ede4a75f758a803fcf42c6e5216d5a2c5c0b57bef2bdac584a83c304ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050281000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002081e2b545c6529ed57196399af39a0825fbd4dd98bfd6783f1c1e62da5441269beeea1c1a001c3915cd2c34251d1f20616a69f45a1416903a4a1d7fdda9561f16304ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050282000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201501eb397159ccac9a18d1bd046421e38e87be69ca608222998f9df57c4f2ee79f526c42c1b96896a92f588fe1a39ed9586dff5b8cd98754758bb5d2ebf31b33304ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050283000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020900764f217d599c1683d8372315444982787985bd68acee94028b6c17b6cf33ae52a2fbdf969fc769b12c7dbb67fc569585ee9c27b86381fa97368efcf302931304ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050284000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201c352a1c742404d36ebccaa5489ed5b77ad3d557689c987317abd041bff7c5844755f74559bdf5c69b6afec728fc20f0f401411f99673b2b888bbb924afcc780304ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050285000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204e511fba1c471f7a232951675ae676a5d6137154f5d6a91f885c5f51c4d7951573145f575d9a1db904f60c2e694671ee1629c043bbf8ab3b1fc3b3aee9aaf2cb314ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050286000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020a5cdb157a807e2336db4d7941b09539c7ab169c0d70064eb51540bcad2c00bbe336be232f3b1bb58dae830739a48f2fc9770bf0329c162aa342c45f445806b14314ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050287000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020149d0e4d68e9bf039219c27536ef0dde92cf952356c98252e9499b03cd60a42b0dca28718fe9613e01e869b5fe02d5c12f6112faa31f79e7148b9135444bafb3314ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050288000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207ef9b4be3630980d9e0fc1b4d96428ce2175ff343b2370daf8ad438946c1f57d3cba1e44976dbfc3cd1b5d5229553bcc7b5fc702ba03826de82bcbe8f0097a5d314ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050289000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d4a756cdc59e307b84d22c72f30e7d25b615558b64bfa40f5372777188fc3fd4cd2376177c6c67890aa6d80155b33cc8d36859e0e10e4843d4aca38c1fb42b16314ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028a000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020439c0c7b5f8b1d1e2d8c319ce1f5ab2995b2d1adb1c3203a60c171f454c4ffeb33c9eae3efab8faa26c3193dc27bce668ade8811f10268d015b3ddd75ff1b55f314ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028b000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020805fc50f9fe75f6dced81924a314b15c0875648974dab612eae3d644bb3b37115b3bf928ed9a9bc60809865393ab80b439425a66a79634cba6e9e59bdb09f6cf324ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028c000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002045df7579e750da19f922f43aa3a21e2da249525ab8cfccd9b71f51c6a1c30bb0856398589407919bd9c5cc3d8c0cecdfc5b551e9f12a7041065776b692cb2189324ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028d000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206eaf4408f46ca6620a3f0fce1bdec4e44c9d1b19d7295af7b6467f4559274083e6aafd20ed380273edcfbf215f5bc3506c11aef3db8342ef614e776e65615f05324ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028e000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020cc3e9b49a553bbe5de4d0e424b1a8a9912e5a3190cd940a5103fb4316d887d9d85f82f10085c76231997d4c41a869e4487c6c3f93161e3a28b803a7bde147cac324ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028f000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030719985e454f387b55e528d20487dc66bcc58965a603473d75b72dc476931b479fac6fffb125d30f4a97de9a74de10a74d3737d36beb426a0cc262d10e625b19c324ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050290000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000300fca9b1dc3a5329cd5520ba4bc68e4534de342b5c84004333d48a7d2890f003782accb5662062fae20db45854f43c86ba45c83795006253e779b806505b4b78c324ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050291000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000300f0985caf9cbf9387360c4d1d0806cd9871358d9efa2f42466799655c3da681c06a83033f35c0eea2ea8ebb02836b37d0fb0c086dd97ff1fa088547e6b7cbe2a334ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050292000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030bd0e4af3c064855f33bdcc8ec995d6cf4651c810c06eaf210138ef8bf60b156a65eb202c4d0ace331468298f950bda5bfd061f26d6f1af9be0a428ebd075599f334ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050293000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030e498621487632eb22abe8e5218ce90a59262bf8305a17ea4c8ae1747951fe7dc6c2d374f1c83482a8a0c1e687850851b3bf6b287d28954956b39a094a6e59694334ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050294000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030ef8197ae7579a94ff6b7522bdc509d2c416933a748b12725ce358f9b4c98ee1991240da3f5025ef164df38d62dbc2da3beb247dd6def9424d653ae18a0199c36334ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050295000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030788a115cf1a5a4861afde79db1a31297aae43bd0696f98a41a3e2d3254f315a37e0af1bff7f6e29b6183838496d2e40ef183564aff9befecf8623a536178e1ea334ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050296000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030aab55d9a6153fe4932e045b83f2f794aa95f491c665134653b92aeb2eae0d0384b99b8a2742a978d92df75a00f1355eb2b27b7d03ee61636541fc3f958f8f8d9334ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050297000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000308ac6ef982e83f704f2c57fb04d599ad7bcb7547fb1c1f14c50e7a75b0ba9603a8d3efaec9592d29b5f5347a18ca39766ca97fff0c585f54711c6d24ec6bb5253344ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050298000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003028cd3d482c7ffd5dbf4f01a665cd9fc920ef311095136121556e4f8e77159de9f4f5f365b53d69d9cfecaac4b86bc02d653152c04803d77192500261696fd958344ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050299000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030e702ff09007fbe96b21ad507417ff969a8c32c8300617660d0ae9507d09218c81e46c0cf839fac82b518f5d618dda53a7f3f80928994d3e4e69fc8a12113ab04344ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029a000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003085230bda07424c8f0ee7f85cbe4ccdb412cd003a386b387ce237b70f687169070abb26eaec2ff325310da247cd3ffc0af289d648194be1d0f180a29e01791749344ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029b000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030b25ee9e478caf1c229fee8e2cf5a9f5f461e05da8d4e67ed58c2b8944463d6ac22bae5eee335ddb91c57b5ebf964c5e159f0c4523c59072be6be09e6b939e794344ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029c000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003088b7b42b02d905912aa865682e1270b8dc66e4381ed89c98ab61a44d66d83fa8f5bcd3140242fce264438ee9f4499d8b0370d264ebc4fe7107d7b4c14168874e344ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029d000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030cb63782d992cee585134d8e1ba1227aacc63564acd1228a1cd055d657fb5f0e30fb677949379d150f0f4cf2d3243979e05af4738a4c32c058d8e1d953f4d66f8354ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029e000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000309273a0fd93f2108e74733f1a5600cd81da1e105ce79c05924554636045b4018c01b111aad61fa94aeec3222ccae5421532a840ed002212b509c608277ebac786354ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029f000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030c23061d78601e1eccb376df69cdd1e1ca210071d81c1f1452c60013cebe12ab7a448021abc938b1d6d504024c48dbeb8bcc971ac9f8577f67a761593c01ea931354ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000308adfd984e743a7d2b3f9a817e0786ee25c7ba09bf2d8e22a50740fb4ccce87f699e0b979d5da4308544d363d6d134b69900aa09ea666ed61e0378117363e104c354ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000307f7c7fb53abb2348b5956b885e6590e7357dc5c461dc79f649f31a2d80cca32fa3974a50a6e9dc54b151b482d7aee5ccd79ee2ab6cb9d7ae76d68f6d1f485c36354ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030628204ee97680cf35da64baa4c7839b98d065f7880165602219574997b7f1c33ba38208b65b89b56fdc0e2aba949ca9c73099dc491b7269bee1921cc0b657c3a354ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030c28169a3ba4cd273e0efc8732024a849d31d52d9ee44599a1feb279443fdfad7e8f8de671a2faa5f4b94f5f219870e810ddd25112143cc4b8c6c4e3940bfe21a364ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000307805b42c0c49c66c2005cd3a59572265646728c457fde1230b7d00d3fc49ef134a222a887b05db5558501762836e4290e80ba0eeaa962b2234280929ccb3d4a1364ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003026050b4d8db4ca80b0b21d1dd5f2f2e1f8376b7a452f5eb308e2d0cb7786a77064082637d3253e02e884fab33b9588cd38acc395be6c104f9e7918821a457196364ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000309cae866d3a2282534fb67df9930bf8c18e65e6400e8318c33b1ea2fc9d7de2da0f857604d5ca34ffa543e8dae8c121832b0946ce4d76d176e71fb902790a1b16364ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003054d6bf9bbe3a759efda7fa5d55ea8bb0d7b8ac2759d9b7d14dd48b7b0117606e64f44c30fe0706640a377787a4f679cb7619103a5512f6b58b310e645fcf16d5364ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003041d023336a9a7e6459741e9365ee341479e25efd26477ff60b46a068b6d1e0d7653b1e42765d3246f6e1913c79f2d12ab4ca903fbc7f5a12b8c0e59d85de667f364ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003056d1cc7efea99b3b6b6625e4945f8e662de89cfad9f7793df74985770b2ec8e929566c1f13e58a0a495f3ea311adb4ed25d2f0ac5e3814010de165986787de5b374ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502aa000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000307a3d15781152f884aeabe012a2f7575de0394915709b391f420a0ffb54f6d36267b4967bfa95e94f43d7e6b31a8501ba604c0106fbe1da104638f924cf86b4e6374ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ab000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003010cb2ee35ae5677167c2b50d1da81663611b527d91399f7e5a1cd1bcfdff1102f318ca003befd0053cb481e39efd57c5961f3e4dc6eb2321f53286485d511a70374ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ac000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030fc1c31bda2f5b04352a79de6386caf339bf69a3b94e750233b01f313657bef257a4aff50bdd8380a79fb52670f16c18103afbf05b5532911471e79c79c72a86c374ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ad000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003064afdb03e5eccb8184d0bfa7ef8cca45ae38279bdda254173ccb6aa24e27e82dd71f1fbf8ed4c75682996acad85006737c4c47c8d9aa6624aac9ad5cb2cdcf78374ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ae000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030aebec63901206c2a64ee0e8ccab520045d350749de6d944ddcb7b790c3eacaaad53daae312806b61022a24d1dc88473bd65b3f6e95b4ec441673bbe962598b36374ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502af000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003022da1f2e5acc898b29266a6df0891c6c2326035a02b7e26a0e892df18716864f809696a8f6d2be8f58e93d1dca43e33aab9e8def80d82a6a23c670518cbb06b1384ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000306c860f93d926f9c9ccef0b10f2eb4f95b82457e8a26abcf2ca5bbdfe2fa49d2e59d7c1c7654bed1b347fbdd54346d3297f9b16f9481a9ed5850771710c100898384ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003028545249173292d951e828c21541b3a71de41870b0eb7214afac5c3f072f4cdd1353bbdc7a0b2ccf0f51d0f429a9676e4e583c1d89c4918e6c26e450befedc5c384ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030255fa6d861a8c30e1f3e0076d231f611ae23fa8e41beb4422bc350b5ca47b323dc693308f3879237b4e1b405410533111c31efc08b3bb242eb293b28e0085f4d384ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030bb137a01ee25cada43c29d10a25c4625025ae301bf7060432d87e2a4c85523d754d28d49189617ae8335675714e6c7c96c77468aba41575f20c1e85646db1c4b384ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030693947bd89787196a6ab30f40c38a2d98937655caea8ebe61700d3c1465b5c098656b03ed899b9031f3e8383e641403d7d0c01db8ee34480e8ae81d52d41a2d9384ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003097e33a83afd78678d686707fd76605b21c8a52f7251b3ff56994c2648b96edebb0de9f4e3d48910ec779245734cd280b35b1a036eb0b562b1c105e383631be63394ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030d78b64231fbc875e9ceccda95a64828a7af148047e364db0dc395e57fde3da4f8583460772359aacaa0eb4935162fdb43b539a2f0f566c92e5fe9782aaf53106394ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000303a48e2b4de856037a9b835ffd895d8c9dcb0ace941dd9275b015e0b3b9e80ddf8a0a731dc587bed23dca20bac75795288d8dc1870b9acec2e239f2fae2621792394ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030e88c1d640cdbd4cdbf12870df51969e0d354bca333ed93fc2f57f5795014839b668ac758f62959acfc6b80db3562552b648a634f7c4d2b3b4c1c53961924bb4e394ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030a32bb197b8ac1a61928da7c02f68a92756085534baeb8bdfaa6d065c5b0bb6487b0b322e695b59eea57e35fbbbf45ef065786a94b3916075dd232534f1cabdd4394ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ba000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000305b4e6a811da62ddf7182e07275eb6c40a2438f29b53e71f2b2c3b0c29dd60ca5af40b8f922bf0397dcbfb875403da906c0c40022a42cd6d469df3c77464faf9b394ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000300afbebd88ef39d68c49947009829eb6dcb4c7e21891b2663658fc38c993bddc5e15efee5b076fff4a7f14c807acf3ff1f4b15b20ac6922202d29a17007b7a0083a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030b7a84d256ebae100836ce7a0d48e4bfbdc4c4d1dd8249b771bc16989b42bddd562b3bd30f926aa46700451aee013eb71e4d025f5d99b08b3467a413681074fa03a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030e5ab8f0b0d3ce14a4da047d699a3dedde63bcf54d10a4f6353bf3e86746f49e34eb940b1e19d2c70b6f271131b861b84559e22971122375fb4a2d925351abbd03a4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502be000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030fde5cc1dd856569772f86309d2107aa1d198d6e28d4120d492b4431e103680b3985fb6ddd770245132cfe8aace771c50a9b32fc4ce99ee542ac1fb7fe869dbb33a4ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bf000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000306cc5717f04eb02103e7bb42fa5fea1cc610a685526e345afd956db031774ec64fc3933f54a84d41f6313d86f9a089b49294e69c5c3e2c32b8360dd4623cd29b23a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030fb07de88eb8139ba0541e8da4668af9cbf73d443ef6a7c65bb3396b3d7059329558fe844dcec51556b37c48e5753005400ec57559876d4d66a796c8a1341ba823a4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030042bfc293aa926aebd5bf2fda24830c9ceca5b28a0e753980d5dbc98e0621763fac2c3745960a97fc07997190021ed99ae6689e121b5f4ad1d2d1b56d68652653b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000303b919244ed96865b7270231d5ae5b2e8b4815caadc0e7f877a546f6bff70569294367983f4543a46c57ab507e2d027b682353d9132cc6edfbd089dc6275b9ae63b4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030cb8a00790d10922b8ae8ff0556b6d4c505a956b5c8782e8292640b2ed5d3ece190316e67b02d67d70958429ae177ef262008f92aa5d0e6e5f735b929e5c1b8c03b4ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000305e5b26f0fabe23852e70dfc470469555bb36794e2c63ca662d0d403b86e2545f9533d6cbb5f35e76e002cea279f4e4e8fe1af1926a989d00e127f5c15978246b3b4ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030ceb1ba85f158f3bc77eb3e8fa9e8780ab14575acf4f294486d9f9c532b3ae14b7164b3697c531927572aea4fa63de2879aed2a00b07213043f4712abf902d9683b4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003075f42da305dff294cef09c25c2a06d28d96c0c8d002050760fb4d94d7a75385fb68897bb13e0a0ebd18a3f92a76f81965c2e81bdcc20f92b1a8d8bc9899a15693b4ae75affff7f200400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030f74531e959f498656396c5346557bad3d98203d1691ab96a7593e219646f5336569c73485915f33ef3c6795dc749c32efe5c7cf06691138dbeefd3c397e232f63c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000309c23129a6e6ad0088ad842077bb1ff08feec092c468d4aca9b3b8f332a2244355537689b9402606742880c99467d80a3011e5d216bf1935cb620e86073dafbba3c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030e770e9a2c7b22168060c12e023add62124608eb062c674511cb44c4271bb8ce61a4755f38b40258a403d609ea254780e21b2b8f7c46e4b768dda2a017bec6a6c3c4ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ca000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030192b89e38aa887fc51e0bcff29083cad1b89a3f28cb4a287d0ad3f57bd81a6213103241fc430bbd2884612603b234a0bc3b186ba43100f6111a8883b36c547cc3c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003026eb8f8728cb9e7adb1734810d64569d1ce0adacd69c0335c378102e0257cc4e251479ff104d6e2be0cbaa15ca4ab0b32f4edf4173c3ca7c9a1905dabd9edec43c4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030823a8ab35f7017be99737b02acf3cd163f1baa9b81f1393d9b11bae062fd49924850edd5901cd508b04186bb25cb5c77506952512d21538bdcb53524154d36503c4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003012f89e1cb63a667b21401ccea764012872c45f83f4982aaea43f0f2bd26df0a18966be6e29df64a1c010f885b07766c5e8503d5fbc40d145c765fb78cc97fbb93d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ce000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030a9f37027c53902104ad251d5697719e0d3da7b31ac18a1c40ead63d5c96a91505168b8f052c9366c58a36c3bf5a8f1e51f39b0400e90f8f068a7b8be2e26d8a03d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cf000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000306253d2f5434249d12e109f084adab1bbff0aa3c78042342a4b293a19adb95d932ed07d4f9ee6671da5c5336971e9df635cfce248b619bee91489e95aaa3d7fe83d4ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030d07a18a83b7d3e99b7854e49995bc183c84ca1288294df0428ef0698625312f62cfdc402430c073c23aee439f8c867da53b2eb505a40d82fc68c4657dd2d01e13d4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030859e58a84653c2ed6c31c592f15fbabbb1a7e0625e4599e985049802aa60f375eece4998904520b6b53bd380d6fb41567ef59e39a392b3116c7ba42635679eb13d4ae75affff7f200300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000308e8de5b85051cf7fdd8fe03792ac99e6bf2f063e1e59dddb6170cd237dc37884ea4a403a8d189c98280d2e2a3c9152594b9a0314a951b08c4fbcd11c281cf0de3d4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000304e1115408da4efea8e7378a0866743c31bdf593b15029a7cf339705f4d0db02e591cbc1a4fcc14478fc218fac1446ba588df192eade9e7f030d654232cf2fdd03e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030b9efe13174a52ccb252dee322370861809d5cebda096fa86839426cfc3f45cdecd16510070366fcdd6bed19d4bd0be327bdd1fbeb0fa1bd8bac5b454227e079e3e4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000304580d9ee64c9c0b760de0069a0842ea64b0306c65d1ad6751bb840880f657e7758b7d15a90d881b159f31f7304d82a7512ff88d90f16501296f57d88ae4449943e4ae75affff7f200400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003027bf82a90a420d2dbd81b5c19707090737dc56a0a049ac84b009e3ebcec72e169c8baea43ccce4ee6af92d8b857674fc667015c460e13452208b7d09c73137f73e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030995039534d1fdbbac86e641ae32129d56a9e4d2ec1739fbc1942a0f3c997d02d0dad8fe0de448c110669a728d968c66b957b78a667099a5189d8efc51541ffb93e4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000304768a3e432d80b397e744660c65c26f2d49c2cf4cbfb6ee094ffadbf18ab1ff37ce6c8011ed9fc8abb2d6d98cd1eab86470f631ac51dd9416ae1799aa0a491183e4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003036f2606284005abe052fa2447ae7d8b288cb7eea1e723e2d9b468443371d97628d86ae8ec7e9a1376300035c2959e1d81f87e015838ca8d682c2f1eabefdcf193f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502da000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000302e32c2c2ce79019058871dbf788c87615d37a488f23f1425b068588befdf98494638b041ce64dab4df93ea1bbae55fa9599d19ede54fdd79755379e263eec7ff3f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502db000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030b0d281d6fa217185a101bdb7c078a7bc3089758b116e6485f473283b2c63762f77cbee33d997369f5553f3be22ac56556e9204633730abc3f47ec2512da1e1fc3f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502dc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030061d4c6cacd1374a69f918c684a7dd57a8ee7ed683450b9878915ea16ebe31aed0ff5e40dac29df059a5dde0ab2316e702b589b1ac703e43300c3a94648f0b513f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502dd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000307d46e466624ba6d72f6a2d14d488296f71370995eaebb4e379248927d4905e9d0eab96c964fa9c16764929e734f497a36a56d3ad361f5afdcf08cb55dc03ba753f4ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502de000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030fb4f097f10e9f3d39d6388b499c8b6836ded207c9ceb39af5c66aa34fac7fcbf7e98fcd8ff229ede4e78d29e388e252a6603cb7fe2433a07da69069d636487b83f4ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502df000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003067c379f7325051e165a989ee9958cf12a696a56900c888763c6821f3f6d63351fc3afc2548cae1e2b3f450c092bb9ba2ff868aadd254078975e7bf020eb2d409404ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003021af0519f8d3eb6e42473d66d175c8e8d6661e5415f71e82d06a762fba40bee3bddfff5200cfaf0fa1fd1b35bf7266e3216be329506df9943d8d686b6721e9d9404ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030c25642bac4a00d81dc3bc69384802a25028fac447fbedd4a553d8303d8c638348ea59fb37ece037c6718e393aaf1ab16a89499d9349e19eecbb8f9bd0aac748f404ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030df1689cefcecab35774629b83eb5b20884715f8c5bf2eb91771fda9075803405c43fd8902c131b167637b0064c4757e77e450d9f868f5f9e101e4deacae1dbb6404ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030bb802914b1a74b4ae3d0e72e8cce56f19672d797ec1f92aca7ac111f589903407b172489c5d534624486077eddfc7ed2a9ca329e1d5afdb335b074e439dd6770404ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030c4ba399044843eddffe4c12c2265759fda4fe86e27c347a7e5ca9dbf0bb80f1bfdfbdc260644b48417db682b79b5ac9b1db5fb407d69e0212809ea9336f4823a404ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030044ade43f8852730a33a64bff5580b54bb0fa04f7b9543bda780f05c93f0bf9d733b99746ee70646479cde411fd45dae66a43c7e3b69477c659e7d6bc02c1a4c414ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030af2990a8f916d45bd452e00e304dc896c778edc117320dc346b9c72b3177e463dcaef26a599b3a5cd11e73843a8f9a584a3cfc2a7b3792ff7874a0c99fcf6ed4414ae75affff7f200500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000301d20eae66c634f7accf452dd8d85d63315a730a618af17e02503130deb1eaf89ecdcf65a15ae59b79a34cc646af05ca4248ee339ab25c645f447af7fbd8fe3a3414ae75affff7f200400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030ecf2a94122e084a170fc3a54174ba94e1ddee395e78986cee2913a22d5536867c4f166844a81190b293ffd06a9789ea7b66802e1ca8388ffd5a83a5879e1459b414ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "000000307a6f4fb010126072560c7347c196b5c14b9a40857ca6be383cf53e61036f974145c4f1bf971cb53035e032e2d784c1da0e211364fc9351b7977b4ccf48b5fb1f414ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ea000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030224e0b4dc44b3c1928e97c721659ec3c78f5d3ad8d4888170c762ae7575ccf97115736c4113735ac0f62718248620ba7f95ca93af71b8cfa45d2a1df755176ce414ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502eb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030c9ce894dd7fcd7f69927ade2d0ed24c070922aa43c2708aa8b1323136f0d4ac91f09e0d3b7bc86448f56bbb91da01b1f6c6f1a69c8f8c8b7243500ad587ce2ab424ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ec000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003002e570af42a6662567849e757f6b4661fb534ea6c9a0a34e4dca582879076cd13fef800f3fd29f1cc70a947e55520a6dba4ceaa8a7cd72fbc89e46c7b485f4d0424ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ed000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030f275432333a1df35e862e716684391f1a8aaef63b8994a7b5c58231ad52d6c46a5ea9d0163a939caeed2ce52cc1de19fe3cd1bb064b3d112052a19ebf57d7579424ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ee000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "00000030d09bfefa5afc86cf4344112ba370a935b1ab67fdcbef1b693402d0dae6176374301bcfdd191bbd6fdf4c72ddeda4347657eae25a6811fb1026e0139126565be6424ae75affff7f200200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ef000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003024089486146412ddb9d82e965474a41dd1362e4353f43409ec8de8d92f7aa9fecd4592844daec828f91fe58c1e1fde74ffce76c43cf3e78bea062d8240ce4bd9424ae75affff7f200000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003078f5256b6b64733186f7d72f99098f7fc74bd591dd4e978b818ff45b60c3f21030dd83d58a60c832ba3b439fb46347aeed5abcec290f85eb97b8084981e1f998424ae75affff7f200100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
-    "0000003012855267c2e62958758e9679dd13446a66b3528c89ab346fbdae093289d2cef7bf69d7e31f8235f8977f191c2c628da08740bbb573afa0354f76176599862e9b434ae75affff7f200200000002020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f2000101ffffffff0258a11ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ed9b390cc1f9db76f50e67dd54b26c6f9069795cf80cff23e84ab9b40a74c38f7a01200000000000000000000000000000000000000000000000000000000000000000000000000200000001b40e4032e98eaddd01559da7cf829651ce78602c8bed0c8eb96d74d1a7a9db71000000006a473044022064468ff0f3e85d9da49b2e391343d78e7415fb4ed2250bf781a5655fcb4df48002202e17027714cdb8d95ee55b009f0b2fef5ded731d4ae2b58b7cd965a0e45bf14501210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3ffeffffff02a88e724e180900001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0080ca3961240000160014829777b472568c0e6f66facc4806a8187632ab57f1000000",
-    "000000306d0063ca8274bb91912f3cd04fe25b8fba253fcd3519c72896ba4be072ea42d05a5a25ba257d29f14814544396a9ea4aed3ace477c853dedbdfe633b1d03b8be434ae75affff7f200100000004020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f3000101ffffffff02404f1fc4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ed97a64c2639d1501564af9dec11b81684296f2fcb2ea92ced93b64702d2ab754c0120000000000000000000000000000000000000000000000000000000000000000000000000020000000001012633786c580a4fe16b86ec566fe3139f9d195403946ad69acd002046b308acda0100000000feffffff02c094724e180900001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac00e057eb481b0000160014bf4a2771c7a20ac673b0d1429c5306f9d8869457024730440220426ebd1dcad0c65dd48c3c37a5a15f8444abddff1f994894971ee97cbe11c9800220485c64b4395792f85f96f5f30c1b9216b8c80dcfe3c95c5d436c6e10fe20e17f0121025e305e0d506beb8c8054179707ee58a15f83a82cd60c96c4d16486f655d0cacbf2000000020000000001011228073484cb422e7a13ecd49b4e4df0ab38b7e391a8b6ee17e2d0a75db9f2970100000000feffffff02c034e59c30120000160014759c853a54b5902b3669d127523f5f3b9c8574b100a0724e180900001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0247304402203a21da378277985c1af93f25161950dcd77b2a9ea2036e1f99861ba7b53e6b86022010077897068cbb52230f1564b8eaccf2ca71d628458e8cfdb71e0973db57f80101210382f07d2f3b41ee165bec9827296de2204ea1d9a8445b7ad49b858c98e9883b64f200000002000000000101569f2a4e192df3aced1463a5175d300c6d37a63496778eaff7106ee2b2acddb30000000000feffffff024067a4d4e80000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88acc02440c84711000016001402b1a067eb4c88ab6d5d5e367459bae1340fd91f024730440220218b6dd0302088b9a9fe516cf7f2eed5f2b6027d566ba5b8533b495cdc67aa8d02201d181c80c03d5ebb2034eea23611bd6ee1a730d8a81aacdf15fceeae31dbec810121023630a0eba24b2dfc7ee0b86a897cbd40c4f55fdb7c5718c20b24e1f1b4963fe2f2000000"
+    "04016200a573e91c1772076c0d40f70e4408c83a31705f296ae6e7629d4adcb5a360213db40e4032e98eaddd01559da7cf829651ce78602c8bed0c8eb96d74d1a7a9db71194ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282a147064f46f8f81ea92dcaf7b26b3466d245936dce0776cdec6f91bffb21ea80100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007ac2be8fa730f906952f5d007b70792edc310b8ad605712636b7e4c0ce0d713d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03510101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a81eb2ff1bf9c6de6c77e0dc3659246d46b3267bafdc92ea818f6ff46470142af75e2cef25e6bc076d1aa0f0927a1a142e6a27e84133bb25243767a6c9886f9a1a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292820bb113dfdd6722ce35372394db73cac747b21b05a6a7fe7cf614e77d5d7888c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ba8afbe6174254102728b32babd7cdfd117c336b6145c7ff95045781dbe24a6700000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03520101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008c88d7d5774e61cfe77f6a5ab0217b74ac3cb74d397253e32c72d6fd3d11bb200c3e3a6176122ff4d6f6a5bdcd38b9b66cf17505bc4a5764f1820051bbcfc0a11a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288a76721cd97dce6441114eaa9535ac459707791dcecb18b4d8715375aac56fee0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000594710c77313341e5598916a8ed612b2e1733fe7afbdfed4f772e6c939a38c2300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03530101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ee6fc5aa755371d8b418cbce1d79079745ac3595aa4e114164ce7dd91c72768aea57c13f65016434a9cafaecd8410262a0c9a65557e5b069c1d456034245d50f1b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289d4fba2bce27f70b88f29fa872a4a32e07f850608f561eeee3116a5dcab3b2ef0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006eef95c20843c1154b47309dc07251c1b87c913ef53b50f06fe5feefc76fa20300000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03540101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200efb2b3ca5d6a11e3ee1e568f6050f8072ea3a472a89ff2880bf727ce2bba4f9d4860de1b20d1268b2169a91df1d08888503b396f163a668bc674083ae3b289771b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292893903cd684f9c5a406c641a299466d1e7b79a009c8354f63342a5ca95df0f2f60100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006e481bce552987eba1726e98004ac5a8eb94ec9764235c60a5cf3e4631f4b00800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03550101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f6f2f05da95c2a34634f35c809a0797b1e6d4699a241c606a4c5f984d63c9093b61b8499ea18f18c5e6039d1942a79430b0c7bcb1a28ebbe57917d2bd6e48ef31b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292816b07427e573ba8b2a2635e8771dca50fbe6e687de63c054d73360617b0d6b2d0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000010770fcd720fdb1bb54baadd9da05ef5f098cf4eee514692665b2b1511ec6db000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03560101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002d6b0d7b616033d754c063de87e6e6fb50ca1d77e835262a8bba73e52774b0164843569ef48be310c335511b54a88a0aefd954bcf508c3d7b69d09b236b26cbb1b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f9d284cc9662e76d69b7d25df373c77c8c8e856b276a5ab1bf0c08ac8dab7ac50100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e485f9e864fb477a5a32fe581e9d6389e987f46f67d486c13e5f4467f831f17e00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03570101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c57aab8dac080cbfb15a6a276b858e8c7cc773f35dd2b7696de76296cc84d2f9cbbc07bc5b1b887061d9e93c0095ef312f8d160751045960ded731cef619ceab1c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e3e7e4b4d1e4a50b3268c7ad8deada0dd74066a906912721660982e81e478aba0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000096f35648b48439d3163475e62fa9c74a565941c55b020483989231fff517789f00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03580101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ba8a471ee882096621279106a96640d70ddaea8dadc768320ba5e4d1b4e4e7e3fd2ecb6a50ffbe5f73645ff49c0bdca05528964f629478481771edbc15025f011c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284bf548f46a84f61f7e1ea18bf774f8ab6e6a5a6286c77839fec1391c4dbc32bd0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f85802a335761048303e2c1d0972a629a74ae596209ca8f1f2bcd78316cbb14000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03590101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200bd32bc4d1c39c1fe3978c786625a6a6eabf874f78ba11e7e1ff6846af448f54bc407c1d3209dc8b31226e58e8b616eb378ced2774943c2d5ed3df0154368f2321c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928dfa885eb6db20e950ffbb29f930b9f7f40b54fbb9203300426cdeab4b69e6d0b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004fab7c3f3ad48e27823a6d42fd2864788c6dac449bec317bb10ea3da0e3b634f00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162000b6d9eb6b4eacd2604300392bb4fb5407f9f0b939fb2fb0f950eb26deb85a8df89cc726c5339dac3d7151037957beb278fef3aca85864f0dca26f76d3657cda81c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a18cafb603448bd406b22a0e43f40e064a18773b19d26514fa81392f3e3932310100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003f93d083ffe3c496ed7d0f1f30dcfa12ee45e8f5b545441f1abe4bd5ece3f5df00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162003132393e2f3981fa1465d2193b77184a060ef4430e2ab206d48b4403b6af8ca1e91b7ca68c31aa6a3d01919cbbb0745b30da63ea585bf3174822e91a07b41ccb1c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280702fc048aab3cc022adb9e510827303d6847c1573c5323484d36e2777eb397c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f9350e1aca6cf7edf6c0d45b828581ee252eb7389da454f194d2b83774632fd700000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007c39eb77276ed3843432c573157c84d603738210e5b9ad22c03cab8a04fc020713ea3255fd4726d14bc54aeb09d91de757df2dcafc4fc8c8618a8de904367fcc1c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d314be4752b97c0d86e47ac6f61db10a2bea55dfcb14dc0875f7c5325caf23790100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003975365e1eb9c71a4cf8db5b53f16397b41b32964d56e70e736dd7f5a273a1cf00000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007923af5c32c5f77508dc14cbdf55ea2b0ab11df6c67ae4860d7cb95247be14d3abd3aaf05202a7469af1589ac690c9da01641a38ff148ffd8749c7fbe29124791d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292827b4ab95582ba40a619e9b25b5863c1d0cdf9e43fe93ea745f14f88993a592dc0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000fd6b9f6adfbc64fd80336e9aa708d906e0d9bc7637a693a965e950110ee30fd00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200dc92a59389f8145f74ea93fe439edf0c1d3c86b5259b9e610aa42b5895abb4278686b394132280553c1bab722522eee155de484e9d07744469c229dfff6862431d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ef8b5d892256c6d60cbba7ad9bea847fc41210988b5027bfabb7119b40c895cf0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000c6075efc1c5ae10e7adc8c26cfe7eef556d5c23e808195fbe76f4cfce40c9ea00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200cf95c8409b11b7abbf27508b981012c47f84ea9bada7bb0cd6c65622895d8bef2c35a1d3464faa96a31b8ee0f21d440d34bf0e78a421d2ae718fbd2d61e4ba9e1d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29286283a5635d5c31d8cebc79ffca15eecf0e4cbcda350fd7b4aa83b639c83916230100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000dc0d6de8b809ac524841b7465001af4cad551ee59dea4bdb60c0d17fbf3f0dae00000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03600101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200231639c839b683aab4d70f35dabc4c0ecfee15caff79bcced8315c5d63a58362a43f17a9d7bc9f30db05d6e7f2c1b843188bb23ac6cfa96054001732419955551d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281218f0bee257637f1a49d8111f357b05ed119c3a86dd4a647cf7df7b5015eea30100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009febddfd6e71892721542518f74d44dba15398f146a2512e4b078ddc5e1a66f800000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401110101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a3ee15507bdff77c644add863a9c11ed057b351f11d8491a7f6357e2bef01812a25dccf782264379b5260d2a6f469f7130b28f891a781cceb5eca24dc6c59d4b1d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292851b27b03d6b0461ac78f5109844eb84a06b8211829823e4c4e805f29581c25150100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000d67078c130767912bdf380a87a39673cecc16b9e1fa098339dd0eda890de98300000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401120101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620015251c58295f804e4c3e82291821b8064ab84e8409518fc71a46b0d6037bb2516a2d4126e2119e6dd207b5b6d3aa694ca3d19f22b42ee9ca3af20f97afdfc2811d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e855aba81a0d23809bd78d8edc8c8331248c79f79dd1aaa5fe9cee9a3491588a0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003c1fb018a427cc90597a610596e11b2125df34cbab8a4030a9aa73eb7fcb5a9c00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401130101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008a5891349aee9cfea5aad19df7798c2431838cdc8e8dd79b80230d1aa8ab55e87d0b8626465b7bbe87c3df33ef0dca2cf149ec1376e0d4df65e729d0464d77071e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292817424042dbf9bc5999858fd458eef7552248108f403d9bdc9eca7c879a93e9170100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b864bffb9969c05f4995de220aa0e4366ba32c68764675cc02d75ef6a4c1d0d900000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401140101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620017e9939a877cca9edc9b3d408f10482255f7ee58d48f859959bcf9db4240421795515e244f1bf7d8c89794bb3d16065a376afc274e57edf11c511c512f54fa811e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287eff71ac695875aeb1718e38206e05640627f5e82c3cf39928ef32fe5d6a61340100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000df57c9ca03aaf1f18fe581702c9f5aff2679123c6a93857e420d9c1f43acca9800000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401150101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620034616a5dfe32ef2899f33c2ce8f5270664056e20388e71b1ae755869ac71ff7e7e417dc5ee89ff08491d4c91e8e36cf43e9ae4ddeaad4916e0ffd51debfde63d1e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a83ce05ced5cd2091515dc6b5ef214285825255c46105e1f2d29cd94f62ed4d60100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001ddac08830cef89ce45f3266354c386bc3de89443c831f5d822743787fc81df500000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401160101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d6d42ef694cd292d1f5e10465c2525582814f25e6bdc151509d25ced5ce03ca8d10a51b038b39075363ae201f1d5acbe7e488e6ae66a604ca2138d8d3cb018d21e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292808e2266de9acd1a0ed5ce8c37e7cd01a0a34a5857d59c43c41c0387925df804b0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000bb8f861e535cb1a475b80707ad0a324ba40355b6a884cbe05b25d896d9a9aabc00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401170101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004b80df257938c0413cc4597d85a5340a1ad07c7ec3e85ceda0d1ace96d26e208e36a79bc1c476ce697880daf8155c8a3375b8eb35b41cc88b70181a8c850a2c81e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928480b65fde8d6e7aa8fe610668d200821ce64c1a5c5cf9d352577e1e189686bcd0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a0183c9a458733cdf18746aa0dbbce5e6260d122cc29be2bd39b8cd0839690e100000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401180101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200cd6b6889e1e17725359dcfc5a5c164ce2108208d6610e68faae7d6e8fd650b484625359f4ea22f53c76bb6defc9f41363eb513ed4acd24b71ee59c08b0b183bf1e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289ea4412aa88cfa70e2dfcc899c9096556db49ebbe1a993027576d690eb0496e40100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000adf707c59a3b8049eeadb3fa28eaca496eff597312916d04f1dcb36d185e5f7200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401190101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e49604eb90d676750293a9e1bb9eb46d5596909c89ccdfe270fa8ca82a41a49e2ac4a8ed93f07f39d81dd4e8a55b541bc1c9b2d517b247314680217fdb0068351f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287502a24dd6b858c27fcfc4a363e9cfcbad90ac0ef329fc1f390a5992af0df4520100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f4858d75af408086260cc2bf737725b07b2450df4dada0f7de17577683f9d6ff00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620052f40daf92590a391ffc29f30eac90adcbcfe963a3c4cf7fc258b8d64da202752bfe715dc17738598b0693f53fe8c52c92889d6d7d138e2faa8b339f4ec7d4531f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281cbcad8e635d6d3c4aa7013ae6762587cbe4e2d4966151116dc88b0089c8fa9f0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000076bbebbe6297c3cad11ce6dec76578daefbd675114330bab64c9ec696450673600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009ffac889008bc86d11516196d4e2e4cb872576e63a01a74a3c6d5d638eadbc1c9efe85cfb8fb03e1baeac0969cf5d96094205bc6a3845c601804e7a1927ca5c51f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292866d007a86488572a7afe470505e4afd79386365bc69548ee818a31ae6c5a028c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d257c72694abaaae98f59131181159b6bf2035b46308872ed3c31578c51535cc00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008c025a6cae318a81ee4895c65b368693d7afe4050547fe7a2a578864a807d066b591d3074309b5da323ac615023f08bf7cce6b49db7715826899a8b5339eec4f1f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283119a431f3ffa0659c1023a84f6252842646724459a27eea160a72a75b50ceaa0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007bf04b5c5e9e2242cfea9f1d0b0f1045c52a514b1b24a09d8b725a2ceff1950100000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200aace505ba7720a16ea7ea259447246268452624fa823109c65a0fff331a419310efdb9d5fd7a876a84bb3ad26ebd3f3c61bdd2b43ddcf0b9deb3ae6e1b3c77051f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292831ec49ed9e43c28e66857cad995cfd963563d0f1ee5e6b5c34461059de8d27c60100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000eb4a206bfd48039e7e8fa61d165952b3582bd2992c39137799c1a39d078b131d00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c6278dde591046345c6b5eeef1d0633596fd5c99ad7c85668ec2439eed49ec31128b2ce073e54cf3d7d909470d88636c91711a8ca096839222de396f0798b24f1f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b8dad542f22842cd7910c32687bc1154ce7eadc4e8532017bbc4550d88f947b60100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000438fcd4c9b8f9dbfec3c32e117c5242a2c0fb22e8fb92ea97cc20e883b812d7500000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b647f9880d55c4bb172053e8c4ad7ece5411bc8726c31079cd4228f242d5dab86f25d446568286f8eacf14b8152b71d7bde97d15f945ee3997a4e96f24920854204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928324ecb21c365f630888f9ad0503d81335f4a51bd009ba3580d1ec2e5a17f4fdb0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006f3e51bffdd244e04d451cd9193d5314647684b628802126cfeb183b6aa1042400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401200101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200db4f7fa1e5c21e0d58a39b00bd514a5f33813d50d09a8f8830f665c321cb4e3206278787e885912c1fe9b08b55697d19a2098c30b8019b2590de4f4ec33185de204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ad0269117ab9e348749ec116977103d1fa214f52090b1ab6f1e41f9efe4cd21c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e58997f9d8e21401461c4f015e991956687a57c988ee14e40e32222c942ece9700000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401210101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162001cd24cfe9e1fe4f1b61a0b09524f21fad103719716c19e7448e3b97a116902ad607d707501e94defcf7b00a1c07b63f861ec2b2b10ae22377aecfbe56ab5c838204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29285a0382c91b00b5423244ce5f86c1a55663b18e158ee51a6ba6b5b02866b0f8210100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002896c6c217f729d6e96c36d549a0200f04200a3f840dd79b0185c194aeec8e8b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401220101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620021f8b06628b0b5a66b1ae58e158eb16356a5c1865fce443242b5001bc982035ae92be068c75e4aea718a96e7debc930169f0da2e12e82c542c23e11a7597d763204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280f97215bc154ffc53a1e0b85b537e390942656b46b642bd74337fedd73dc0b5d0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002f183cbd9bd3d157174050a5207d26ff3fbe64d7723ce186539c0fde614ab1c500000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401230101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005d0bdc73ddfe3743d72b646bb456269490e337b5850b1e3ac5ff54c15b21970f51e3cb0877e932083c1ed1fbfe0b2a80a11b539e7726c943a45a59c4e200be90204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292898ff959107f76c12882c9fdc57559243d6956d3a1ff69d277986de381a44c3bd0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000647704fdbc6c576dc155ae8a6625cfa38188afc0d905043033545f3b0fe73de700000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401240101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200bdc3441a38de8679279df61f3a6d95d643925557dc9f2c88126cf7079195ff98c35d7a1a3ca59328aa2a574bebea8d0e964485290db4f448e832f812bf843d56204ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292864e49b945466dd0ae5ea31a9a1193866f69068e581ecc5f5bc1fd6779236fc7b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007a6abc0f1f7422e98ac11f9bc8817bb5cc68b6ef1731421104313dd4ace9421100000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401250101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007bfc369277d61fbcf5c5ec81e56890f6663819a1a931eae50add6654949be46484b9dfa3cce5d627c889a487df9a7857ce4eaab9a5f876f33302a198aba62f5e214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292868e34662b5005356b26c90e032b75d1844407ea1776847451d77354ab4455ba10100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000cd460492cf58a8bd622efffc7938c4203843eedeba887fbb143c07dfc3115dcf00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401260101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a15b45b44a35771d45476877a17e4044185db732e0906cb2565300b56246e368cf1678e36d905b9932cc68b581aa8f5058492ef554d7c40550efe86b0d7b57af214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ab7ea6121db3742b51aeb1c993706ce2f3995adf067cf98085001f402d1cbea30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ffa473e76a606e75afb449432a0d002218de011d8456e8237ecc7c45409938c200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401270101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a3be1c2d401f008580f97c06df5a99f3e26c7093c9b1ae512b74b31d12a67eab9a0a742b3aa4e9a09bade628984fbded4ca4fdeb3546e4b0650d2712caea7fb5214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282e894ad7d72e4f19936b7764070c7e519575f63e799e70025c913be6e4683cd60100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f3e09443746c2c985ff3f6ee95d163a77fc27610efa5b86df1d5f3b09fd5858c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401280101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d63c68e4e63b915c02709e793ef67595517e0c0764776b93194f2ed7d74a892efbeb6f108215a05ed342165e9f78cafb71c519ea5495c608756c346d7396a244214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292877d3ebe909f47ac2b1d5d6b165226a256fc1f013056bae9a6ee39e356d7bf58d0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b4ae2060ae97f819c853fc236bad10f1e2b2187be7b2c71a3f35a157d7aad1aa00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401290101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008df57b6d359ee36e9aae6b0513f0c16f256a2265b1d6d5b1c27af409e9ebd37793e680e1aeade31f4c41024af841bb4342ac9263831a8bb60b49118b99c82b69214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292867959627098db8d7bc02d03c348da2ff6ad954654a93a54266a56c2ad7749b590100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f7ed7e94c46f76e60efa5e0fef1a6133f18704c881308b534ace34eaef345b2e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200599b74d72a6ca56642a5934a6554d96affa28d343cd002bcd7b88d0927969567f2e479371803409658f07d1226ebb853f26052bf2c32c772600f9f9f095d89e7214ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287a2ad26dbe73272f9d76833b288ba657d650d1bb5548b30df9dec826dacbaf190100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a321e35b0c981fe2db2867d514d45429c67d70ec2f045e9f1231d98bdd82c5fc00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620019afcbda26c8def90db34855bbd150d657a68b283b83769d2f2773be6dd22a7a82c31483dac7f3e29abc8ec8b9a44dee570d30bb0bbb919b3daeff4f2bc13371224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928211dff15bd265cd5878bfbc8fb1a359abac9bfcb45689c22cd4f06e305f77b9b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001b4683fc9a9c09342ee73b71bdec825ed626f94d9ea913d8ade9623061bc0cf900000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009b7bf705e3064fcd229c6845cbbfc9ba9a351afbc8fb8b87d55c26bd15ff1d2105af0434465560abea118d2b0be44fffe70f031eafa432d518ae24c1f04dadd5224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292882ff05acb5e80c82c97bd90cfe3ba823c3487bb128a1765ea291fc68c0bc3d940100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000035980f598b308f27e4b705b9867a2280f8b621dafd25a0b30842dad22ee3064300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200943dbcc068fc91a25e76a128b17b48c323a83bfe0cd97bc9820ce8b5ac05ff82ecc5344c2b300d49b595c67891a663566b4c9ffdc9afa13029a26335ed25c457224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282cba8dd9cece59446f62cf41e9a0a5a941b022f8110d0e2fd2921b469900ef990100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000008fa129665427c8b907412e63c5e0f46c8caa2a124082e9bc52caa9b14f332a700000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620099ef0099461b92d22f0e0d11f822b041a9a5a0e941cf626f4459ceced98dba2c2dae27037072caf5fa97c166bea89df60cfadbd116f9ecaafe453aaa230532ef224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292852d479e9db040a53a4e56f054b014ecf2b77fb2e16f4455ca9d38635eb9f094c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000178cc01dd564560ac13f602a74658d045105d878a5c09cd0d82c49b6a92fda7e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004c099feb3586d3a95c45f4162efb772bcf4e014b056fe5a4530a04dbe979d452d3ea2c2ea321a720b1774ff6b57da9f74e259edfabd6b889c83f7619ce916938224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ccb37f9fbc9fd4dd3a2c92a6e39c7ea019863039c9ec2f839c2d5c409c8573720100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000023e6925bdff3eb1404814d6126ab894cc82f51a917bca4e98b696cd4810298b500000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401300101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007273859c405c2d9c832fecc939308619a07e9ce3a6922c3addd49fbc9f7fb3cc63bbb0b67dcb1f83215eab58279f49517a3b2f7f3e93533a88d99788020cb99d224ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292858392c5c9f90c413455b607f254a7dd2f4e5a9417a2eda66f24820ee2e607aca0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000feb3eb61e7f653b52bdc227f794648f891265a6cdb4d3499c9678b55b2fb0d0200000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401310101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ca7a602eee2048f266da2e7a41a9e5f4d27d4a257f605b4513c4909f5c2c3958803a85dc54fbf2a041dbc2cdffb33b15913c644155e8d297007cb809040c94e7234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928abc0289f5377e558c76d072f87d81514d0aa73c185798c97b72b888698f2f2630100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000750dc356031e21b5ef48c7be6b68cb707809cb4616171ade6dd5abd2efb46e6d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401320101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620063f2f29886882bb7978c7985c173aad01415d8872f076dc758e577539f28c0abaa0616f42a608ad43a421e758231a21216b0b366f2d50bd4fd98a7a1e0b5aee7234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283f85720b5302291ad24882d7dd076a744fb35357b80d028281fa06cde0c1a25c0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000003580cc3370b649957d029b15085dc26bb70f8821b0d750372bf24be0d13d89e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401330101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005ca2c1e0cd06fa8182020db85753b34f746a07ddd78248d21a2902530b72853f5237ca5189d4aa4385b29035457a9e1c8b2463512f3881889370dfc0cb9f5813234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928385008e02a5cd73a5b2994d9f2953f6d043de15e383ac18ed3c9e599b1a472710100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002a436714d7ffdb69ea9bbcdbc8a08cbf674e640f5973ff7cac482675a013067200000000000000000600000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401340101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007172a4b199e5c9d38ec13a385ee13d046d3f95f2d994295b3ad75c2ae0085038a4e483bfe855a0a0903afc50ea72fe551fccc3bfbfa33eabd61fed1abe75e721234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e93aee22d3130b02274e51d2741b563841e045cbf91996367f0d1a13113fffda0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ccce23171e529e62a7e7f5d3204419c5972022500f9e65680324fab6a78e8c0700000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401350101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200daff3f11131a0d7f369619f9cb45e04138561b74d2514e27020b13d322ee3ae9647f06f82b76dea8e3b81acc164cb2e5ccc64f78cf191b28ed313225cb38cfaf234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928bb11391a4b47cca77a338878b46bfd1b2601dcd21741114e6d495ecdeebb1aa90100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c4677610245ba35e6da0ee32b2d08dc3030ec26ee3c63a183c97bf94af2c3f7b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401360101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a91abbeecd5e496d4e114117d2dc01261bfd6bb47888337aa7cc474b1a3911bb0cf088861245b3d3d16453a8ac34ded5336542c5699cf7b5c55f89fb107c7f7d234ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292850b4a4dd7df06a5dc75055d52aad97d21173148cf67900ceab1aff27b38e8b8e0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006471594ec72965004153f3569ab2f62f5c69c5ffbbb95a19b01a0640a9f1ef0b00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401370101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008e8b8eb327ff1aabce0079f68c147311d297ad2ad55550c75d6af07ddda4b4508df1a30ade3e06eb1e9b289d1e0b9d79debd88b8b32022e41ae889008b873963244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287cbf0d2058d67021a2c6cf1855dc67f0b9c4a127976d93e7b59545263bb4744d0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f5bebd4b4263580eeeaf23fe7b8a19c16734c451317bac97ce469259aba0e24a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401380101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004d74b43b264595b5e7936d9727a1c4b9f067dc5518cfc6a22170d658200dbf7c474b4eacb7d3309d45e889b7d65f4824a05adc3f5425e95d3725bf7fd35e44cb244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d9291c6d9c70b03adc00808560b751dd4bb659b9d5c71e0d560037088b4216f00100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000095546cf5ad7d9a164d749f332620d133267d4836ecf4e20822cf0af54ee414c00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401390101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f016428b083700560d1ec7d5b959b64bdd51b760858000dc3ab0709c6d1c29d9cb19d5db44e188c0301ae2de87e57f9df0a5a0a10f25c4dce1bcfd84e451dfeb244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b2ba4ec111dffbb76e0ceb221418bf11b158ccf3ff7916a46c752d99f20417250100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000012374095fe45300658fbf1409d659ba71dcc426cce6d6d9df77145a8911b780700000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200251704f2992d756ca41679fff3cc58b111bf181422eb0c6eb7fbdf11c14ebab2f312690ad49ca5336fa2cc39a3dbeafe8ffc618b9c1de26375972212e7bc9544244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292861778e14ffd6b4e0e3f9f1c535d3767e4eca7b98d30cb821fcd877bd9d9e20ef0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c3fa349601df2d794f0730a25c7c58c7c927b2458411535c029cf32cd1ca411400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ef209e9dbd77d8fc21b80cd3987bca4e7e76d335c5f1f9e3e0b4d6ff148e776128484a4310594dbc1f2b0cd5174bab0cacc202299e2414719dac17bba002cdef244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29285a31e16f4292b17982283de8ec886a8949ffd0fd39f3798d3f7f7a05361556e50100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000090c2ebf5821e8ee84636c5ca751efb7ed5ab6b6b137965564c0ee42b245cd3f600000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e5561536057a7f3f8d79f339fdd0ff49896a88ece83d288279b192426fe1315a3b0ef6d4726a2fd8910aac05b388bb52f91b9bfda18f3e34e45f3cf8758f4418244ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292831464537e4c7df13261cd66ae10b343281705454fde93bdaebf851aa75bd84df0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000408c3ec4dfa6c158f93f95df33f445337612bcd5453b2ddc72eb724d5ab9265900000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200df84bd75aa51f8ebda3be9fd5454708132340be16ad61c2613dfc7e437454631fd569603f075b948566c403f27c9e7131b97cbe12d8f0a86bf359f8c661c1056254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928113406872b3e12b07d546c1b25356e588e4be89a0f1aeb1ca2a5518009158d8c0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009e51dd2f515ac44dba3449ed5cbb5e563eb08c14d0e1b312e69ca5bc2ea9090100000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008c8d15098051a5a21ceb1a0f9ae84b8e586e35251b6c547db0123e2b870634111779cb660c8142a8fa66f4f2b227e5558f13e2882ad1c8c87c422fd9dab71eea254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292854507effd01b3041e3930e76d34f4e315b904e34544b98c4f703cf74190d39d00100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b28dfb7ab39db5c7b21b1307e1b570e5f263ecbefe941e53d16111fea6c9946900000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d0390d1974cf03f7c4984b54344e905b314e4fd3760e93e341301bd0ff7e5054f603da762ca3e32f7812a848d8d0ac66f54395db3eee8953d25a796a77bce05d254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289725bc6c3a1471bfb4fd42204d5e5095968d2d4e0cce3d7780bb192dea7c93e50100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000035e471e7637ff34ff1035394f40ff719e699001dab2dbb8f5ebd2152f26d1b3200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401400101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e5937cea2d19bb80773dce0c4e2d8d9695505e4d2042fdb4bf71143a6cbc2597b607d59ddc5648b983a9279d31a74313ad8db8497e90c95381d02adce5613b9a254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d3d08d214b5a8d75edf3eb376393b12ee3d6e1566b33915d2bce0f7c9c8478f20100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c9d11c720a380147c7bc014619afb46ed50fe956daf7a59f0f506bf067b2441200000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401410101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f278849c7c0fce2b5d91336b56e1d6e32eb1936337ebf3ed758d5a4b218dd0d321d462160ba940356a52bb4014b167ca6c491ecdad7c2789851703b3d4188847254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287ef24e3879066efa80f3fbaacd8080c076801cacb4941ab5e256778f06faed150100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ec222cd74556b524edbdb805b445582cfdc17fcd5a9388328eb9d80023d5921300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401420101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620015edfa068f7756e2b51a94b4ac1c8076c08080cdaafbf380fa6e0679384ef27ee90e17bbab10f8e1af8d10029a84ee2a971472e540ba27efa14664847d7bfd96254ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ccdda26551f12cb4546f3faae9dfd690c7b0ccdc24f5b4c5b6aa0f42137566520100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000de38906818f4f4b055b4b397c765d433feccd8278c7568525fd71895e97d14bb00000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401430101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620052667513420faab6c5b4f524dcccb0c790d6dfe9aa3f6f54b42cf15165a2ddcc3e25ef3dd966dc85197a48918800df6c792828a6b649253eccbb90a9fe1381bc264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288ae3ddf967f2acf9faac0ca102ed0b3b45525fa5e2bd88e4373f78b1af2db6740100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ae1d1ccec5ec49fac4051310332676075a76e0a4ea55fcb4bd6ab3ab3d6eceda00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401440101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620074b62dafb1783f37e488bde2a55f52453b0bed02a10cacfaf9acf267f9dde38a32076515b4946271b4d30bc59ef8d4ea4451147eae091e5f38c73887205828e2264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f26d0b200f87645c42ec0107cb17f4a28b9cac453f6a172ab61b47f0cff8f29e0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003df896b36eeec99e8ac41e955d71cadeb4796a248af8ec75bc8df9925f894bcb00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401450101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009ef2f8cff0471bb62a176a3f45ac9c8ba2f417cb0701ec425c64870f200b6df29f2d4a03373ab2f6bece4e9fc108c540f6f1fd3133246982654c60cf65e57d3f264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284e25d17ed82bcc8fc31ebdbde08a6031e06708c8b8b882b0ecc57f2f88866fa00100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004b4dbff52a0eb65200c6b1c34b3a0c4e62b551ccdc53167fa66dae3d5bae10f100000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401460101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a06f86882f7fc5ecb082b8b8c80867e031608ae0bdbd1ec38fcc2bd87ed1254ee488002bbf188f8560b05806f443c7d3c876f589ebfb26cbe06d1bc400dcb354264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292897e6525487cb32f015f9fa561726b2c93cbccc89049e42f90996741c1e7042020100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000b64ad075a3516604ccba11041af633d7f38a9e877e2d0cab50765e6de94e52900000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401470101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162000242701e1c749609f9429e0489ccbc3cc9b2261756faf915f032cb875452e6975cead78faa4c4de5aaf1af45847042328aa948b9d40f6db59a0d28c2fddb5572264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e9f098dc2e936b8f9f892801ae4b6450aa31816836f80ca30c0998aadc1196580100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009977d867ccbe80ad7a7fc67eaeeada9970af722bab79a0edf92902701dc5fd1200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401480101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200589611dcaa98090ca30cf836688131aa50644bae0128899f8f6b932edc98f0e908547c332f5ece4ac74b9184ddec493918932f551d0a806bddf69736f562341e264ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292802e254a83f09e9c1b6910a48b03588b2b796c86148a4c29fba7aa5731defb47e0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e052beed2f64652435add83fc26c1891a7173d81a56c6e87fce9e4a4a1270ba700000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401490101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007eb4ef1d73a57aba9fc2a44861c896b7b28835b0480a91b6c1e9093fa854e202df56d380deff815e91760a599bb322d5e2895595b0b7891ad4f604c1413a2815274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289fd93644072c05f72675139aa084c8c8f50fd4433af02d41f793582cbb557d9a0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d598e51db0cc3eea564cd62cb35327de50bfcfca761c182e95bc5613e443386400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009a7d55bb2c5893f7412df03a43d40ff5c8c884a09a137526f7052c074436d99f93da92685cc7d12fc387bb8f742463321c5d64a6a94a557da83bb9b615f5c3a5274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284fb5a28c54e16978bc972fffc0150bad299c91e8ece080474976d6a37f8e6e320100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000a417293a2120f513f16890af131368d450e342b532f6e239d272efbe33c70f800000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200326e8e7fa3d676494780e0ece8919c29ad0b15c0ff2f97bc7869e1548ca2b54fa7f555a5dbfe331035ca85ef4e1687848ec6b7fee5e3d11a4c881fe2fa7c29f4274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282cc57b3ba76f5f3ec6b99d47eb374e967e6d8363fa0a670b447cf868f82619a00100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000bf8862777b9316d8e9e9f4a10ac47ddbe13e2db1da84322c6b1df603ad2c22c000000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a01926f868f87c440b670afa63836d7e964e37eb479db9c63e5f6fa73b7bc52ceb44a480c641c2a3b090cffdc54e36f4a2fcdd66a600b6371271fcc446ae39f3274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928546a6697638d84af18d3458cfd52ad1b927f13a680752bc480d7d0433e5528f40100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000005fdbf2697da8d75889f84e78c4f50cd2d2dc3c2ad9a68b81dc7581897199e94300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f428553e43d0d780c42b7580a6137f921bad52fd8c45d318af848d6397666a5420db43df1a4ac71c25a63c294813fa0217414d5dbbdda98babb9a0698b861724274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288bd3645344590342effe96c35bbe858b76998894167506fc62ea576a8055a0540100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a978f6c74361e280282f258c8cf8c309197b3117586317a2aa6fb1b930ac1b0e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620054a055806a57ea62fc067516948899768b85be5bc396feef420359445364d38be747b039403939b657d36e7ac59d5467b2520d02addb0014292a4892105d198e274ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b6723cec8ed51deb0724cc4a65f9eecd3e85839a57e158848aeef48edcdf89460100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a940f1acbb27cf562c30fff40730d9caf32fcc4de2331e5588543e144de57cf100000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004689dfdc8ef4ee8a8458e1579a83853ecdeef9654acc2407eb1dd58eec3c72b67371b37a7deea0d85aba44226d29b411eeb20e9dabf0c74b767e61a7b413acd5284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d7394a765677319bf2f58db6f33c4fe2385ea6142c383e6def4c1184968a27400100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000020298d644966cbad809b407648f7a790e4c3d6a0f41f6dee4dc88b1cac1ad35e00000000000000000500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401500101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620040278a9684114cef6d3e382c14a65e38e24f3cf3b68df5f29b317756764a39d75ba82a108d691667e6506c11cc652c6628a355b8818df5a919c4bd67d2de0a45284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928cecac579e46aae0021970b4ca6c32d3081566fdfef3078fdf3c911c6f8847d720100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000351a8e959503ac92d21a403e7c709394809d828d45fddaf7ec325a9a621636d300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401510101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200727d84f8c611c9f3fd7830efdf6f5681302dc3a64c0b972100ae6ae479c5cace25a15d14bd25e27a4cb3ba7a2ee148f21e9574dea908ecc1a057372bea5d9fa5284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928924ff83550746cde1603ab7de0de82c0ab5d50bf6683164c3738603ba8f9449c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000972fdcd8196b30b904126c0b2ff606d9e7c31b4c15ec7b030887a05d074fd02c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401520101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009c44f9a83b6038374c168366bf505dabc082dee07dab0316de6c745035f84f92d07c793a0dbcebbcab30d3a4d4efac18b9f1538d77ba8e326b14c82ed261cf32284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f49375a5bb71369de2043be213dedb7ede57f18e4580ba64c39bab9680128fb40100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000caab39b9333c18c1addbcadbaf85af2512f29635c6ddfe8851175781654d5d1a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401530101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b48f128096ab9bc364ba80458ef157de7edbde13e23b04e29d3671bba57593f49eb9470d94f10e6fe67d170c066208a6aa73b25c84eef366f7533acde32f5798284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292859c4f2c14403ab3428b05f5fc6ed32e7dd377691e8d3756351945fd5800a44ee0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000005aece853271441398ae5637f04055d61f01d1d79b2a9b31a0af310a3fd5a945300000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401540101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ee440a80d55f94516375d3e8917637dde732edc65f5fb02834ab0344c1f2c4591b67caf16926291b24f219b8c579734c78f36e582b5805f799be5aadf3d7e38b284ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928984bf5ca7275131fa1b265c32ce32d826f0fdb9899306c6c1e97f447e800a8630100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ea804edd0300c0fe7b924d829bf03324c30c9a4120a75fe9c3c790e2568bc8a300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401550101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620063a800e847f4971e6c6c309998db0f6f822de32cc365b2a11f137572caf54b9845b76a1790cfe1334bc6ebaf94aa72494da9504b76edd0a7654f8c359086d666294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292893f7ce30a569ed4cda76b6dbaee89de2932cd2ce5f3b180910401c7a99ae9b900100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000e94b8f4e627890cde523260f730cd69a54ca2c54be2e8bbf7b22e35890593c500000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401560101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200909bae997a1c401009183b5fced22c93e29de8aedbb676da4ced69a530cef793452418d8708fe47265ad57981f12ece0e586fe847be239278eb470d0dcaa019b294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d15e08b42b0f4360fd7d9e3d97975405cb0f0fe216bcc2973cddd96c1c7cc5750100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000028cff2e1e90c368c7d290867ed76e818d73fdca5da61e8fa360d155da8f3e4f000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401570101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620075c57c1c6cd9dd3c97c2bc16e20f0fcb055497973d9e7dfd60430f2bb4085ed1292a893996d465dbaf56a6bb3462bc16f4a59c3f5072c8b4ec90fcdbdbab9dc2294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ed0f421ebaa5f4bcc96bc6186599f71c668c15f991665f72793f0f2b968b7a810100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000151a2b85a510b084070bd751a489dd5e6b1f14ff0a223f9014e2dc4825e9788300000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401580101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200817a8b962b0f3f79725f6691f9158c661cf7996518c66bc9bcf4a5ba1e420fed88d0966cea8f2440953abfd723c212f62735f9034d10684f2a04c0e76ec08f10294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ed6dd250c4216976f148c4ffd388739e87dc82b0855ee1a1e6cbc4a20511d0410100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000aeb6d924a1dfd24e9198064546743d926c1e82f35e35681509b8f4e0d4a18f600000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401590101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620041d01105a2c4cbe6a1e15e85b082dc879e7388d3ffc448f1766921c450d26dedb4fa7f3266d560c5783ca20431b298c90c3b3c236215f9a4bca120b034a51d96294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f65f59c8a4ffbc27d5adae65e518df832fd95a9d7cc33467374827c3129319520100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000064cfa196e45ad4e5ffe9d63cfaf995aa69c01f1ba61132c98b013992f075781a00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620052199312c32748376734c37c9d5ad92f83df18e565aeadd527bcffa4c8595ff6c2c53cbc4dbcb5e88353fc6553c3cea509297a47b811c52034b85bb41dca4275294ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a808259464eb4ddfafebeee3266fa0686cc612210a9bed6a03d6b0b6af23295c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a54d15f112d95e4cd0d72986e1bc698cf70fa5b574ac9696714f96bdf690fc5600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005c2923afb6b0d6036aed9b0a2112c66c68a06f26e3eeebafdf4deb64942508a894f6df10c90e7a8d7fb0de04a495328d7ee90a6aa5d40f1192e92f03cedc58902a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284828712643329878a76c614ce256a877a020dd766d553219c36b70f11816ead40100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f5507fd96cd4844f21cbb3a9d998181aff4a58f899e754cda6f816bc0d60927500000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d4ea1618f1706bc31932556d76dd20a077a856e24c616ca7789832432671284864a3a926d8e2b5d3de9d4fc5acf25712c585ccf1ca986185b4ae570df2aa259b2a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b05cb65bc84cd8a8374b25ab6e9444476770c8c780d3492e577eb573e4f8adcd0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000779f66471ef0824b79ff1724278fbd31721ca15cc64b528224389880e015a7ac00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200cdadf8e473b57e572e49d380c7c870674744946eab254b37a8d84cc85bb65cb094b0bd8b419a4311fdcde709ed54525956d652f1c7a0049da4df36bdb9f524aa2a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292895ac5254aa7bc6a0095a7b0e0500006f0ee5b6e23a74412316c249bc3eae8dd50100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a5c97850670dc8429e7ebd9ec9ae2735bee931400b10e42483151e3d787d57a200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d58dae3ebc49c2162341743ae2b6e50e6f0000050e7b5a09a0c67baa5452ac95ec00071519a45cdc8ef5bbf109ceca3bfd85594ac6a0aed34a95f0f838a4c6182a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928bec7df0ec2f3340fb1f3549d6bc98077be77b04fed38d31bdd9377e50be9a3f50100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003930ca08484f51931aa19f138cef2cb87fc88ebe7a55044caa0c0c969a3b198600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f5a3e90be57793dd1bd338ed4fb077be7780c96b9d54f3b10f34f3c20edfc7be8aae6cbd53b2a43fce81a9e0e880e6898d44553147c54a5abd7dc5228d2274ed2a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928eaf48ce3ca1423c7d20ddb867a6cb99c9d16caa9bdfe9d47bbf2a7dd150f900a0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fc1715c716841275529a95d01dcaff4c1fcd28acd4dc64e589ec8f2c6e44654c00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401600101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162000a900f15dda7f2bb479dfebda9ca169d9cb96c7a86db0dd2c72314cae38cf4ea5707cbdbcad1f56abed1d202b9dfb9c7984290de1b05efae2df45d0e50e2752f2a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292845a731169b0cfda2a0ff513f5d99242729390e4093ad4756f45617271b5c92eb0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000049f7140dc89453c8a54e0f3568db9818caac13d0c68dfd35697d58d76e729e0200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401610101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200eb925c1b271756f45647ad93400e39292724995d3f51ffa0a2fd0c9b1631a745da1dd7555778cb4f24141d34def48c1a6e43cea0f3784a21e7b367e42a09cbd32b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287549d59bf30da629bc208cecc1dfbc126ff934dfd6e6d934f7153514028284ce0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000073dbe49c174fba90f868df081db44169b36ac8f447a10601f6cb89e061ade19a00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401620101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ce848202143515f734d9e6d6df34f96f12bcdfc1ec8c20bc29a60df39bd549755f7dafa529c7472d47b32de80fd454cb5117f3f6dce5c14c25b6948b5d66de7c2b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282a3d5cec2312f3bcab8c4022f5eab9b1fa9351fc1e274ba19ca8a5be738d83980100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000915486ffc9d29b0944c59ec1fdec8d7547cf13b532e4ec04de2decbe37e4c09800000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401630101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620098838d73bea5a89ca14b271efc5193fab1b9eaf522408cabbcf31223ec5c3d2aa0b7a234a1eeebafdfdedca088a40034f0ae91586e254ef175f41d93292dfc002b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281b0879e10e33128689c2bcdbd4764c556ac11a3b5fb8c1d7a0163c6f127127160100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000044efb226140b228b655c8f50afff83371673b6bcddc3f786b08daf64dd1becad00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401640101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200162771126f3c16a0d7c1b85f3b1ac16a554c76d4dbbcc2898612330ee179081bfc48ca3ddb6c183e3deb4f4c8c56bcb83f9aabbcd4bd9a189a76c01da50cbc722b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288c36163fdf4456bc739a38de447b49c8b1407ad647be6594012fbc9edc7635ab0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ad5e661da253498a026b3a76a50c2de8253122d5849bd728da59ec43883a641600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401650101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ab3576dc9ebc2f019465be47d67a40b1c8497b44de389a73bc5644df3f16368cdae04c86109e15e1c655d97edcb3029b3260c1af6a59f4488c865b27feb4e6ee2b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280f0ae1919f6619c322f8bef9f09d90fb7c312ad9b29c174d7268c596eef3348d0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000036ba86f564562b9607eee5aa197f5a5443cffccc93e00699e849948ee53293d500000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401660101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008d34f3ee96c568724d179cb2d92a317cfb909df0f9bef822c319669f91e10a0ff534e65eccb9bfbc1e7cb56e25e6cdcc8ff966516249635fb17dbd89813ffa042b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29286f7ba671b3beceec639416e0c9b4ffb17f48e0658ee2c71f2ed152019e3965d90100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000cae66729183b31dacab1c3e43b6fad18a383164c51dae774541a7a04ce1f080c00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401670101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d965399e0152d12e1fc7e28e65e0487fb1ffb4c9e0169463eccebeb371a67b6f6030d1e7053a8aabe2c8fe44bec4df0ad4ec6130467899f90aefc9d43bb80f962c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928516841d547199817b5379add7e90a19436e15f45265762453511605f8b0035f30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b2b6e2d70d042a8ef63c2534215b25eb2318099d0e8f260938c4d0372aef757300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401680101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f335008b5f60113545625726455fe13694a1907edd9a37b517981947d54168512696fa30728552bdb615d5c3f6c2bf1249a9e199e4362aae88064806349a36602c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292882d203cbaaaebcd909a89b81719dfef42f42f87efb2f68ce6900089b5f8719690100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000087e097d7e3261b3cfbf8aa2a757bcb042eaa289d0ffc75b6134752ae762350d100000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401690101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006919875f9b080069ce682ffb7ef8422ff4fe9d71819ba809d9bcaeaacb03d28258e3643d5cb560d8a97af5bf6c733ddb1e1766f280c1db2dc6b52ed3ae04aac72c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288e477862370a90088be44ea2b3f9263accbb04c5e04f9d232f041b90f4db06d30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c657c17e67ea2025afbaa2b868a6b02d5b6b9f61da2ed98359802e661094f0c500000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d306dbf4901b042f239d4fe0c504bbcc3a26f9b3a24ee48b08900a376278478eaa13649f1218e4aef9317b876e4152bbbfa42e874167c8248708e3fc50163f772c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283fc51b81c4f779190b42b646144c572e03d838dad3017760a2130913a90afceb0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000dcd78debd0db656c76d1837d48d9a865bd580be944bab6f1f7f6e100ee4172a700000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ebfc0aa9130913a2607701d3da38d8032e574c1446b6420b1979f7c4811bc53fdf34890a7439a2f0ea002394e04c7925e8e40edc76ac7711754b45a30c5b5c972c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e5c89b21cba219370d170e38f1959daae5d173c4e5a44ec2a50295723218b6370100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000147fdf05678671e48fbca404ca177415c0a80337fd9f130b6fba2835f09e5e7d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620037b61832729502a5c24ea4e5c473d1e5aa9d95f1380e170d3719a2cb219bc8e5f6b48e5948d891103d477a4ac55f7ca7cf3b04cebbd4bc1a6706a1b87b14817d2c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ca63accd11846e5693fd67dbedb1fb8323649ed24bceaa90e65f22dc5ddf0c210100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f6e00fcff656ab6fefb659835be574f4422ae843d6a7ebe6617e4dff95424caa00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200210cdf5ddc225fe690aace4bd29e642383fbb1eddb67fd93566e8411cdac63ca2a884520dd628e04a57bd6f90c9639dc0da180aa5d888fad779c3311b3a654602d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289e72f7b48643b967985546ec690a0154a763245f4b67ed290285a202db2d0a4b0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fd03a17c413f854ef10d5c879f95f658f1bf2a403b30d6c9d4ea27ce4097a91400000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004b0a2ddb02a2850229ed674b5f2463a754010a69ec46559867b94386b4f7729e9acf192cac6b33d9bc53a123b8b8403d1efcb8bed0470cbab3648aa6b31e957b2d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292828f6b3b5d9ab5651146fbcf05844d6f3daf3bcde1a119eee7ffde2f0fc5fe76e0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000018611cdb76346f7d6f8f2d4402ecf8f8f0e4160a0ed7525b48f6ab326dc3689400000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006ee75ffcf0e2fd7fee9e111adebcf3daf3d64458f0bc6f145156abd9b5b3f628393c68fbbf7d4cfd4e4c1c194f75d0ea803dfd43a197869e704394e3186a9d452d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292853e22e74f5134e4dee982c3cd5d6400c29078a666d0311d1bfb3243cea8e74a00100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000daf8d23dd76435a448e6aa84d2da3cfefc0c70959a8f96e251030b7ef7942a0700000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401700101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a0748eea3c24b3bfd111036d668a07290c40d6d53c2c98ee4d4e13f5742ee25325282b876a5e2cccae63c8ee5273c7e609249c93a77651b56ceda6c3705004502d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d2e4f03db1ee939cc0e68deb7eb08104c56da2c55cc157bc7212bdb9471f58c60100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000006cc05a3c707ba8a354e6a040c5a7d1cfdff6441ea3c3ee7f2bc4409e0a5b97e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401710101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c6581f47b9bd1272bc57c15cc5a26dc50481b07eeb8de6c09c93eeb13df0e4d2baff6cf10091f1fadbf7c68e9b39c1f0b674d85641984241745e97ae6df409a92d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287d27b97524db2cb9d7d41f1aa23490a55bce0548a716f5f7d0c4d282bbac42b50100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ebf732ed761879f00426dd9097eb0d503d0d484e52db51c9fe8ecc2e3273a43a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401720101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b542acbb82d2c4d0f7f516a74805ce5ba59034a21a1fd4d7b92cdb2475b9277db4dab36d5f3828645d3b3279261ffe931b47a1bbd14d22aa59ece3e6cf0f43992d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282236d855aae9bd61142ae5ac5059525b620c297c37f4c760df0b2acbfe906cff0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008d6b81b69ea2a36beb8697eb30726d2343bdfd03690435e35caeece56e5873aa00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401730101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ff6c90fecb2a0bdf60c7f4377c290c625b525950ace52a1461bde9aa55d836227ad08fa3a63aa359ed7c2596382d926a0de61c1d2e346739c5d4b3ff944918222e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292895ebaabda7534a9263e5e2d9517db6662cc15968300a03b20e27fcb1e5ef9c290100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001af0756a4ac567c7a452d90ed0f76e61a42a2f006046dbb45a3c3e60aca38e6e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401740101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200299cefe5b1fc270eb2030a306859c12c66b67d51d9e2e563924a53a7bdaaeb951ed9fe8bc6b228aa3300a00573273848dd170b1c07770d83f56d5e2696aeaa8e2e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928df43cb3f4f6b928d3fdcbba4f1cbe33d07e0e7fe04aa87be2fe1e9be2fe5d7150100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006f45782a73e015065229f227e9872277680f1d9f170d27d1711f1d0f2bcecd7a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401750101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620015d7e52fbee9e12fbe87aa04fee7e0073de3cbf1a4bbdc3f8d926b4f3fcb43dfc031d30e38077c849412ecb96000fbabcaf0949ca4c7252f2bea8b50f0d755ed2e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ca6e2a8d88f0be25f0953684ca6086f0945fb643d9c97b97c46bedfa659c5ade0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001a6aa9b8e011bee91f194b045fbd7e38e78686a20e359e7be606fa4d29b6303400000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401760101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200de5a9c65faed6bc4977bc9d943b65f94f08660ca843695f025bef0888d2a6ecafafe9aac9b83ed83504b9f36a45d9e7363f160d28740b66b5747ed1ccd712d1b2e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e876d463cd731677c0a8b1ea4c5d0dfa4c8064a371844b1e8a5c43e6b2ca42440100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ec4cbf108bba795f2b3fa4cc6d668914a874e4dc905ef70a0e6aa96589c2eb1100000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401770101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004442cab2e6435c8a1e4b8471a364804cfa0d5d4ceab1a8c0771673cd63d476e824bfdfcad86ac46dd219701ef0ebf4c7b94573941149a82a34145ae2aa03be092e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280e8dae3c2b3a1cbf8b576d835d0cd5aebf493509ab5ef90394089723406e0f500100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004957eb2daa75b104043037fa62571c8aeef0a18f0d207c810d2a7a161eae3a0600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401780101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200500f6e402397089403f95eab093549bfaed50c5d836d578bbf1c3a2b3cae8d0e7a9c63fd2ef583d1f94b2b489074cac8c16de8292a3ef8b11e170de2859656a72e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281d9307032d443df6a0f316634acc1a583de148aa494f927e6f7913019f5af04a0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a8e1fe54048db5c9d51c8615555034c5ee849b48e56970372ae0c78f6da2562d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401790101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004af05a9f0113796f7e924f49aa48e13d581acc4a6316f3a0f63d442d0307931d42c2b2f25a0f8df8296ff0f4f5cfa4b9488ef17917e01b6e4bdc2c96e7b8864c2f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ed97cd41dabd7f1ab0b30d2f61838ff75dbe0174bc4ffa3f8b28b5ce0c58246e0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f1cef6315f10fd8eea5ece66539f477de1ea10b0bed04efb489b84b9e3ded8d700000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017a0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006e24580cceb5288b3ffa4fbc7401be5df78f83612f0db3b01a7fbdda41cd97ed7ff22f538cf08a527f39f015bc380fd890bef5f066e2f86fe150c442eb069b4d2f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292893619a759be5aecc85031d70a86484d17e2a73b691a9882b486d7d651291b6e80100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ae63493a67ed100f9bcaec07a4694db94af1b4e835f82de3982fe11c8cef793300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017b0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e8b69112657d6d482b88a991b6732a7ed18464a8701d0385ccaee59b759a619394f77126b8a8600d6a5eb58b817b18a1ede25a8ab38f26b9ddb8f653fe0628e52f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283714d96485c3d54dac5ec433be754051173f8aaf2bf2cc567691fc65887e358e0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002fefe94d11dce4aa13292fbac086d2e8cf53408c7872f774ad7f271038ae095000000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017c0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008e357e8865fc917656ccf22baf8a3f17514075be33c45eac4dd5c38564d914378f7fc3bfcf363e3ce275268f714a463e9161a8f7d9d770279c289b34b4ae5a792f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288729d5262cf617342602d210697fa590a5fc5c34d99ce6f601123011e3d1ca6c0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000031e58ba1bf6be9d0c400caafd965bb1aa0bb42f48f2653c1d54d4801f94eab7200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017d0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006ccad1e311301201f6e69cd9345cfca590a57f6910d202263417f62c26d52987206d3ed0c8970241bd417e0525604adba077e1cf5cc22f251ea8f0cee6303d092f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284742ed77ac2b63059d541867cb4beeaeb08d65233fb16cf0ce952885b148ba4b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004b16eb1bb810f08f1105916ca4045925ef9adbb4d8c152474192f4ff8f37cb5300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017e0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004bba48b1852895cef06cb13f23658db0aeee4bcb6718549d05632bac77ed4247226116b282507e43d3fff4eb78629f9a5d07920ed45a30e414c95d611d3a83c62f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e6a4faff04d57880aa60a33fca982767381b78d769474ef68537afc8305b76e80100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a3910d2293acb756bfe449b8ec01d7b77360caafe5c6bd8ff6fffbb0467158da00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04017f0101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e8765b30c8af3785f64e4769d7781b38672798ca3fa360aa8078d504fffaa4e654afbcd2a6842515ed26522d2c100c4b3d8f98aee64bd8eb219f50504b3640ba304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282820ee5f5c29b148812962b5674280ecf25a524a7e8154c449b68174dd9fdc980100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000026805571a25f9dd3902b30b07ec49ef2695669ee94fb82e42e7a3ac02859150600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050280000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620098dc9fdd7481b649c454817e4a525af2ec804267b562298148b1295c5fee2028976441b7883ede4a75f758a803fcf42c6e5216d5a2c5c0b57bef2bdac584a83c304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292827efccf2d9ef29e7942c0f9060afdb2fc22e0a9cbc1048d16467eeccfd98a9af0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001180b55ee5f5676eea8b652403f6988bcc02c1a6bfc617b1893de542dd9f04f300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050281000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200afa998fdccee6764d14810bc9c0a2ec22fdbaf60900f2c94e729efd9f2ccef27eeea1c1a001c3915cd2c34251d1f20616a69f45a1416903a4a1d7fdda9561f16304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ac108bb00b1f1a6e4e7a65c1a74235d1fe620686367e1df2fd5231a87ca1aade0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002faf32b7696503a322f30f82bbe42ebf8578ba02f2c4f0e86128e3c135574b2e00000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050282000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200deaaa17ca83152fdf21d7e36860662fed13542a7c1657a4e6e1a1f0bb08b10ac9f526c42c1b96896a92f588fe1a39ed9586dff5b8cd98754758bb5d2ebf31b33304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287914493f21d5628417cfe0b203058d2e04978a21cc5f39ac04434e9bfd7d99600100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001d1368726ed88be1e8f6dc75de92f1b2b7276bf036a5c9237c818536266795fe00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050283000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620060997dfd9b4e4304ac395fcc218a97042e8d0503b2e0cf178462d5213f491479e52a2fbdf969fc769b12c7dbb67fc569585ee9c27b86381fa97368efcf302931304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284bfebe179e6fda00ac6ce69be38f8e433079e8f7d5dfa5c3a499d79ddf4646a50100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000048f18eda8798966111c1fb61487de0a2422b5fd421ae7a14f4d913ec026d8bae00000000000000000600000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050284000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a54646df9dd799a4c3a5dfd5f7e87930438e8fe39be66cac00da6f9e17befe4b4755f74559bdf5c69b6afec728fc20f0f401411f99673b2b888bbb924afcc780304ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292852477bdbabfa19aa504f4504132b9e1512696da180ccac790ca939bffaf2f5de0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000052abeb34371cd9c0596ff1ac45484c6ce7e3f6c819a0cf54eeb238426cb904b300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050285000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200def5f2fabf39a90c79accc80a16d6912159e2b1304454f50aa19faabdb7b475273145f575d9a1db904f60c2e694671ee1629c043bbf8ab3b1fc3b3aee9aaf2cb314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a103be0be627fc8bc0276207603f05175a030ea7007848bc4b73699bfabf13b50100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000052776dfd47ff717cf2747d8896b5e1ce8ebbc9205133236027721a0ae77ea13700000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050286000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b513bffa9b69734bbc487800a70e035a17053f60076227c08bfc27e60bbe03a1336be232f3b1bb58dae830739a48f2fc9770bf0329c162aa342c45f445806b14314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287a3cfbc2b8dfd8ebe19df3ac5a18fffac862debd297c2f1638d8e23ed2d82bdf0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b59a1c6ef5124a111b5135fe40a3bff36184a21ed866ed4b799de03be6ba18c900000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050287000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200df2bd8d23ee2d838162f7c29bdde62c8faff185aacf39de1ebd8dfb8c2fb3c7a0dca28718fe9613e01e869b5fe02d5c12f6112faa31f79e7148b9135444bafb3314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928acc2cec2294d728ab867d319468317a217afc34e5287cdf542161534a822e4740100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a411fd399d4d533dbfca2a3ec6267ef22808309edce959978fc9d2f1b6f4129800000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050288000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620074e422a834151642f5cd87524ec3af17a217834619d367b88a724d29c2cec2ac3cba1e44976dbfc3cd1b5d5229553bcc7b5fc702ba03826de82bcbe8f0097a5d314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292852ecf0fb62a0dbee94fd20e069be88f29b7fc0cb631f11886e522dab3c129bda0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000042d5545ee7c4d89b01984cbd279edbaa3c1a37ce38341860337a9d79ac794a7f00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050289000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200da9b123cab2d526e88111f63cbc07f9bf288be69e020fd94eedba062fbf0ec52cd2376177c6c67890aa6d80155b33cc8d36859e0e10e4843d4aca38c1fb42b16314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292836428040a1a55724d69a03287a95b2d36fff41978c448679d0a2ed22de2c6ff60100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000efc03ad84fd9b1e4b471273df9b4787f2a27f51ed8f51d03d66384c0132672f300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028a000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f66f2cde22eda2d07986448c9741ff6fd3b2957a28039ad62457a5a14080423633c9eae3efab8faa26c3193dc27bce668ade8811f10268d015b3ddd75ff1b55f314ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b265572442d5e09a28f8a0f8c4a890f28ecaac1894498fece2f6978ac580e9be0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000091ee1b6484e4820485068f12d93a83a9ce34113d57e6290742403fdc13e50d4d00000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028b000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200bee980c58a97f6e2ec8f499418acca8ef290a8c4f8a0f8289ae0d542245765b25b3bf928ed9a9bc60809865393ab80b439425a66a79634cba6e9e59bdb09f6cf324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928749f8c7515223d481788502094c0174aac67572a5b9d20b0651afceff248cdb20100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000026017c3261cc1771b1deabc569221cca8804358197150c80d514a7cdb76f466300000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028c000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b2cd48f2effc1a65b0209d5b2a5767ac4a17c09420508817483d2215758c9f74856398589407919bd9c5cc3d8c0cecdfc5b551e9f12a7041065776b692cb2189324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f1e1ca8bdd9688309522cbd2c8309c93d2f2abecc23a0a2c8c2823ff3a2ff4d00100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f4d58ae99106fac31d758223814a10b4e8ef0fb7faf3b308d902cddb76e2d44000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028d000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d0f42f3aff23288c2c0a3ac2ecabf2d2939c30c8d2cb2295308896dd8bcae1f1e6aafd20ed380273edcfbf215f5bc3506c11aef3db8342ef614e776e65615f05324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280e2ee1cc9380d8afb28c5cdeab9e7132b2895b9830cb35153c458c5865765ad40100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007d21917e2ccffa2a021dff3934cba1e93dc8fcd2bcc9f6ad23dfe87150c85abd00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028e000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d45a7665588c453c1535cb30985b89b232719eabde5c8cb2afd88093cce12e0e85f82f10085c76231997d4c41a869e4487c6c3f93161e3a28b803a7bde147cac324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928faaf4884b1f4ff33c0d82eeaafb4b5b73e4cdbed7fca11418e4e9ac202e899710100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e106edec1d4e6b1db80ef8224073499c6b5e2cf539b2c51c72e831f6a8ab69e200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05028f000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007199e802c29a4e8e4111ca7feddb4c3eb7b5b4afea2ed8c033fff4b18448affafac6fffb125d30f4a97de9a74de10a74d3737d36beb426a0cc262d10e625b19c324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284b50ecd459065b9f392effd5c60b682eef3ea52a2c7fd9ca7fb83fff363c2e2f0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000df08a9632843f0715cbfae905f634a9af4e7807ef3b013530990fad07072512b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050290000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002f2e3c36ff3fb87fcad97f2c2aa53eef2e680bc6d5ff2e399f5b0659d4ec504b82accb5662062fae20db45854f43c86ba45c83795006253e779b806505b4b78c324ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928695f83cf3e3af067129f9e7d117fcd747d83c4f1650401f9e85a5fd527aed9cf0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b4983e6a46fa161ebbbbdefdb90469166d65353e479ac209b59aea53d6803f5400000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050291000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200cfd9ae27d55f5ae8f9010465f1c4837d74cd7f117d9e9f1267f03a3ecf835f6906a83033f35c0eea2ea8ebb02836b37d0fb0c086dd97ff1fa088547e6b7cbe2a334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292890eb4ea6984db205d3863acc8ef99fbb33d4e975a67ff181bafef6ccaf887e490100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e2a22fdcabd26b7f2532a04d18aa539715a82d41f6522ad708018f292af6014c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050292000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200497e88afccf6feba81f17fa675e9d433bb9ff98ecc3a86d305b24d98a64eeb9065eb202c4d0ace331468298f950bda5bfd061f26d6f1af9be0a428ebd075599f334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928eb0382c489cfb43ee2512f52e574ec407239390b91b3deeb9c3e5299bd9fff210100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008f25dd290e094c9d24fcea593d7e2581c2c9d96e3e24de35da989223d15c1f7e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050293000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620021ff9fbd99523e9cebdeb3910b39397240ec74e5522f51e23eb4cf89c48203eb6c2d374f1c83482a8a0c1e687850851b3bf6b287d28954956b39a094a6e59694334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292877e2f4cb5c93a70d82d12755bd726530a0e67cd99d4fd93f6a04a107ed2431810100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000158a26db9f82f176d49784fa38b73e361f44c87fa2a30becbf0ee20b6e6c038b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050294000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200813124ed07a1046a3fd94f9dd97ce6a0306572bd5527d1820da7935ccbf4e27791240da3f5025ef164df38d62dbc2da3beb247dd6def9424d653ae18a0199c36334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29285bc492afff9c81bc635586e670832885628c989aec4944069a3b08f0ae8f12a80100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006a5e1d094e5a87d9819b94eb790ec36e8af3d1a896933fc515d6cd60c7ddd8f500000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050295000101ffffffff0200203d88792d00001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a8128faef0083b9a064449ec9a988c6285288370e6865563bc819cffaf92c45b7e0af1bff7f6e29b6183838496d2e40ef183564aff9befecf8623a536178e1ea334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289bc1815632901da4c2292b2d40a54005b74a4f50766c93c36db20ca9f23d87630100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000059f0989e6b1e640e3f3842be02063ac5cb15b488a3e5b97e2a49d4be7b78631200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050296000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620063873df2a90cb26dc3936c76504f4ab70540a5402d2b29c2a41d90325681c19b4b99b8a2742a978d92df75a00f1355eb2b27b7d03ee61636541fc3f958f8f8d9334ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283d5b848c01b35f6fd5f6db375912773adde6e2fe92727ad37628ec054ec5071a0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006d9b55d605e01c8834b42bad244a0430b841599f8ae0dabfbbe0cb89f081300c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050297000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162001a07c54e05ec2876d37a7292fee2e6dd3a77125937dbf6d56f5fb3018c845b3d8d3efaec9592d29b5f5347a18ca39766ca97fff0c585f54711c6d24ec6bb5253344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928c99d619eeaaffb527c7290deace0d8709917293ad46f7cb644772ac3cb7393ea0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000065b6db0e8856828b448c7666b2078fbffa75a48fcc8ac851b3c249d698f2362700000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050298000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ea9373cbc32a7744b67c6fd43a29179970d8e0acde90727c52fbafea9e619dc9f4f5f365b53d69d9cfecaac4b86bc02d653152c04803d77192500261696fd958344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ff47f2ccf6bbc5a5d3457a5a16596847a58aca83bfbc8279905d05bc5c2af8280100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000001c8fd8117164f8a55dcabc7fe04e78710795cf07531cc612cdb2274f1ae2113200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff050299000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620028f82a5cbc055d907982bcbf83ca8aa5476859165a7a45d3a5c5bbf6ccf247ff1e46c0cf839fac82b518f5d618dda53a7f3f80928994d3e4e69fc8a12113ab04344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292894ea33058a38ccdd121d8ce564aad0b26c6c1c2c0ce63de5de6a43fc6b326ebe0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000021257c3b336c54a0f2bd94815241a0ddf5bf0c0d943e3377a93b1e26e49a2b4500000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029a000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200be6e326bfc436adee53de60c2c1c6c6cb2d0aa64e58c1d12ddcc388a0533ea940abb26eaec2ff325310da247cd3ffc0af289d648194be1d0f180a29e01791749344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287b7a5b542e71f6de7fcab9d0ae9cda81dc55a09f95b59176e9fbeec63bbc13f40100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000bbb7859bc746719a122bc34185b8b1ecf63a139abb1fc3a4959cb610469e351000000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029b000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f413bc3bc6eefbe97691b5959fa055dc81da9caed0b9ca7fdef6712e545b7a7b22bae5eee335ddb91c57b5ebf964c5e159f0c4523c59072be6be09e6b939e794344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a14bf896c2d0deb17e4a40b281213ec7550397dd6efda7e38d6de90010b548f40100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006059a5a0addfdd9022f11cf2a26d804703a81ec472eeaaf710f6ff871e5c446100000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029c000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f448b51000e96d8de3a7fd6edd970355c73e2181b2404a7eb1ded0c296f84ba1f5bcd3140242fce264438ee9f4499d8b0370d264ebc4fe7107d7b4c14168874e344ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928878f516036136f6171604196660dc0996e69654826ffc5aeb821d6d4a2c1d2280100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d87ea379caae9e7ebf81608ad1c4bd444af5ce2619008f7576027f262bb3746400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029d000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620028d2c1a2d4d621b8aec5ff264865696e99c00d6696416071616f133660518f870fb677949379d150f0f4cf2d3243979e05af4738a4c32c058d8e1d953f4d66f8354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b4154e2b96ab803fa5587b95d9dc3e2589ef9b6ddfc9caa22c26e051279102fb0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000071be7383b9773cb740e660818b1997a5727c215f34bf90e98bac96dd2755f9bd00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029e000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200fb02912751e0262ca2cac9df6d9bef89253edcd9957b58a53f80ab962b4e15b401b111aad61fa94aeec3222ccae5421532a840ed002212b509c608277ebac786354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928440d88fc6ca979da524962595ae7be1b8942a970b56681a3db99cd3459d08a910100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f88ae2c595b14311b4fd8f37f7afb39911519b75ca2074b570d25ca7fad7f43300000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff05029f000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200918ad05934cd99dba38166b570a942891bbee75a59624952da79a96cfc880d44a448021abc938b1d6d504024c48dbeb8bcc971ac9f8577f67a761593c01ea931354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928c56ddbf922f1876637c7a29a601f403eeeae1369da7d656db0f078b636a859380100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a771570b8e661b26b9220ca2c3b631f8f22a9557a8de44344146c4e3e1f27a4600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162003859a836b678f0b06d657dda6913aeee3e401f609aa2c7376687f122f9db6dc599e0b979d5da4308544d363d6d134b69900aa09ea666ed61e0378117363e104c354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ea76711470532e3d1711507afe220047ffaf7b9800076e41fbab9070bddd54c30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fd92015c0698c1a904117649e4a2c22f7a7ef17593030cebaa5e0f1e7ab37a5200000000000000000500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c354ddbd7090abfb416e0700987bafff470022fe7a5011173d2e5370147176eaa3974a50a6e9dc54b151b482d7aee5ccd79ee2ab6cb9d7ae76d68f6d1f485c36354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292822f0209aacdd71dd9ee00351510d4e41ac612155fd90d833e338653fd93312a30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d722f6a88673c9f0dfb8d793e635ccc64e107837f0724193512dac508894706600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a31233d93f6538e333d890fd552161ac414e0d515103e09edd71ddac9a20f022ba38208b65b89b56fdc0e2aba949ca9c73099dc491b7269bee1921cc0b657c3a354ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281e58c0b08ca714e821fb79d0168dafff1f6b9cb18823a417ba90516c73d866460100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000001292ebb336e72b917c0ea25240560dfa9c0774868d2ee65aea1fc252fe8743700000000000000000500000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004666d8736c5190ba17a42388b19c6b1fffaf8d16d079fb21e814a78cb0c0581ee8f8de671a2faa5f4b94f5f219870e810ddd25112143cc4b8c6c4e3940bfe21a364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928132c4d9109a30e4ef42e88c5030eb49710513e29017f70918dd7fea2d5a3f0b40100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fc0be71d1e383ecb8eb77a6609ab54186d8fa087cb80fd169f750f1050279ff200000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b4f0a3d5a2fed78d91707f01293e511097b40e03c5882ef44e0ea309914d2c134a222a887b05db5558501762836e4290e80ba0eeaa962b2234280929ccb3d4a1364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b3b4dc94aacd31c4167b6e4eff8ab6d11407992449b6eaa2aed3b915469989f70100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002828395cdaeef77b11511bbce852d6eacf8164d085b833e431272a8f973d3c5a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f789994615b9d3aea2eab64924990714d1b68aff4e6e7b16c431cdaa94dcb4b364082637d3253e02e884fab33b9588cd38acc395be6c104f9e7918821a457196364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292800dd45ec30f01e3493d1eda16c36ccab8ab0ab38ffe88186c2a4fad847ab6cd30100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006376c34984680910f37642e1591863cafaa853568359b1d6f19869abacf49c2c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d36cab47d8faa4c28681e8ff38abb08aabcc366ca1edd193341ef030ec45dd000f857604d5ca34ffa543e8dae8c121832b0946ce4d76d176e71fb902790a1b16364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e10da7f2048ab40374487963c26bb449019b1c644757bc86d30c84576eb7fd270100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e41113746ff9193e9e661e954dba6d3374d17a34c707775099135c477fde2dfe00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620027fdb76e57840cd386bc5747641c9b0149b46bc26379487403b48a04f2a70de164f44c30fe0706640a377787a4f679cb7619103a5512f6b58b310e645fcf16d5364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29287dec263783687e8124f4d30ba9ce418fa33aa85f068f046f6983770fc6b7d5880100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c11f9b979be52b1848a948d8c4345ec5955fa681237db1e82f504f01b91b2b7400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620088d5b7c60f7783696f048f065fa83aa38f41cea90bd3f424817e68833726ec7d653b1e42765d3246f6e1913c79f2d12ab4ca903fbc7f5a12b8c0e59d85de667f364ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292823c257ad06b629de51720119948e5e83f226b89f64058110fa45386725f3c74b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004d9f6d65108f4318948b8525ea14e02c8de746b672dda686c957302672fa8a5700000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502a9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004bc7f325673845fa108105649fb826f2835e8e9419017251de29b606ad57c22329566c1f13e58a0a495f3ea311adb4ed25d2f0ac5e3814010de165986787de5b374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29286ebec3b411c6ec382cc01b895bc0297577fd73207d5ad8c389df2a7d79dd80240100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000067a8ca44209f8d34caa2c9e86cce8fe5c37736e0e5e36751a78712adfb1ef41d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502aa000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002480dd797d2adf89c3d85a7d2073fd777529c05b891bc02c38ecc611b4c3be6e67b4967bfa95e94f43d7e6b31a8501ba604c0106fbe1da104638f924cf86b4e6374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b00ed8cd92cd9965cbd986817e187b195c90291c4d72c08fecec48abd99b4fbe0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000051190174ed20df88160fd94271039135ccf54f7c8b6e41cd85d78ff15a07ac5e00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ab000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200be4f9bd9ab48ecec8fc0724d1c29905c197b187e8186d9cb6599cd92cdd80eb0f318ca003befd0053cb481e39efd57c5961f3e4dc6eb2321f53286485d511a70374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282f4b9c9a72c4a306f961c52f1f8ce2ed51c96df3d82d01f3d036caf8af52e49d0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000049e7d10b27124985a13a3aeb18af0498869206aa47cc51496438722ba055320a00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ac000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009de452aff8ca36d0f3012dd8f36dc951ede28c1f2fc561f906a3c4729a9c4b2f7a4aff50bdd8380a79fb52670f16c18103afbf05b5532911471e79c79c72a86c374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282b0446e302c95fa465801ac4b00e6a7305e6bf7c18ae1182801f948745d9b70e0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a15591b75ebc7fd3c2adb0424c333ced82ded5c26e0f2bcf9a1ddb2a1574784f00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ad000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162000eb7d94587941f808211ae187cbfe605736a0eb0c41a8065a45fc902e346042bd71f1fbf8ed4c75682996acad85006737c4c47c8d9aa6624aac9ad5cb2cdcf78374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292871fb390b67b6563d6b5a10bc900c89a5a7f934483a89e8f8fa45f413ed45b4a60100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d091f7d95549f72e57c92240dbb3548a6840550d48adf31090cd880a6ed1d2dc00000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ae000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200a6b445ed13f445faf8e8893a4834f9a7a5890c90bc105a6b3d56b6670b39fb71d53daae312806b61022a24d1dc88473bd65b3f6e95b4ec441673bbe962598b36374ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284762a1d0861dfb3a5b1216c7aea401d417ead7f571e762aefcb8df44cf1a73820100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000cb10d4b7b0d2f9318f54fd7a0fad81bc02339385c62c221ec3ddcc61c4b69ca400000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502af000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620082731acf44dfb8fcae62e771f5d7ea17d401a4aec716125b3afb1d86d0a16247809696a8f6d2be8f58e93d1dca43e33aab9e8def80d82a6a23c670518cbb06b1384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ecf45bc30684e59c1c38d1036a89e626f3d17df9da7c2dfecb4c73de74fb45b10100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000dac4e8283d602459c6975e97408c76d3321eabcd9fd6aa6e666b838d58109a7400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b145fb74de734ccbfe2d7cdaf97dd1f326e6896a03d1381c9ce58406c35bf4ec59d7c1c7654bed1b347fbdd54346d3297f9b16f9481a9ed5850771710c100898384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29289069d0ac3810f97e58a6f1b806cc2552c383eb3848600658f21d2fe8891eb5420100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a53852f295ad721354322d141ab1e233743a1bae80c127054d1f743f4fdb0d6800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620042b51e89e82f1df25806604838eb83c35225cc06b8f1a6587ef91038acd069901353bbdc7a0b2ccf0f51d0f429a9676e4e583c1d89c4918e6c26e450befedc5c384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f9be4e9bdf9f26b03b7823166b8a44f03ce1b9d22767e6b7624220a137d7c8990100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d3707b39c5b9d39093c5b4a8909284c9b39d4b3e698b4b9a7ea362e8e60794d000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620099c8d737a1204262b7e66727d2b9e13cf0448a6b1623783bb0269fdf9b4ebef9dc693308f3879237b4e1b405410533111c31efc08b3bb242eb293b28e0085f4d384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928dd96829435e051e0e9c3ee386fea62aad98713fd3a2336ca819450caf8883ffe0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000079c916d98d12d248a4a5ac1d03ca54e89f3ab288f201b31a35eaa847796f0fe000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200fe3f88f8ca509481ca36233afd1387d9aa62ea6f38eec3e9e051e035948296dd54d28d49189617ae8335675714e6c7c96c77468aba41575f20c1e85646db1c4b384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29284f722a9e50fc2e89be476252ceca07fe1ff06c2097ed126ff636d58e9d22e4bb0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009ec22059ebf771b94362457c83e59bd3875730aee2f2503ac5c6a8de8ce3871f00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200bbe4229d8ed536f66f12ed97206cf01ffe07cace526247be892efc509e2a724f8656b03ed899b9031f3e8383e641403d7d0c01db8ee34480e8ae81d52d41a2d9384ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b20e2d1ba4743a9d69b020390f16284e46b6ec40454d8a1344ba5b7c4275671b0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000787bcfb944484f71af0989a29a6620b49ba08ba5e83798d0928d2fb3c32123e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162001b6775427c5bba44138a4d4540ecb6464e28160f3920b0699d3a74a41b2d0eb2b0de9f4e3d48910ec779245734cd280b35b1a036eb0b562b1c105e383631be63394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ae573a552c9daf53a5ca0ada6056e9deceaa2914dd0151284a2a60177c1c3e410100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000083034d4106986bbfe08e97dc2baa1fccec99a7f1b26bd06374057e1356d2f3b00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200413e1c7c17602a4a285101dd1429aacedee95660da0acaa553af9d2c553a57ae8583460772359aacaa0eb4935162fdb43b539a2f0f566c92e5fe9782aaf53106394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928d0b6fa1a70047be796b4bdb9771357f11d96b5a3a79e631f19a4d714a7e2af150100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a66a43a83d37a855ed765b3c1a7502f81fc8840c4a47fef6df279180122d8d9400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620015afe2a714d7a4191f639ea7a3b5961df1571377b9bdb496e77b04701afab6d08a0a731dc587bed23dca20bac75795288d8dc1870b9acec2e239f2fae2621792394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928192ec8e3d83a68b00a29d64302ba08e2de4417dabbae04a23968488d13e4109f0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000071bf319ae60d0f87727390ab8d2446c9e8713925d5d0286658f77871cca2f52f00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009f10e4138d486839a204aebbda1744dee208ba0243d6290ab0683ad8e3c82e19668ac758f62959acfc6b80db3562552b648a634f7c4d2b3b4c1c53961924bb4e394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928738b7b3b11ebdd16521eeddafa4f35dd5f6f2c9dabebe0e25a26051f29344eb30100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000097d2a66631733508914df29d021750e8f6cbbbb2eb02a237bb33e43144f665d00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502b9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b34e34291f05265ae2e0ebab9d2c6f5fdd354ffadaed1e5216ddeb113b7b8b737b0b322e695b59eea57e35fbbbf45ef065786a94b3916075dd232534f1cabdd4394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281f1e3ed622040238410d6ece6589e005b913b8975d961194b9220284c8bc0cc50100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007aaccd4506bcae20d86a63331153e8495b768ca6585d9ed0887c24847b4ab00e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ba000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c50cbcc8840222b99411965d97b813b905e08965ce6e0d4138020422d63e1e1faf40b8f922bf0397dcbfb875403da906c0c40022a42cd6d469df3c77464faf9b394ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928fdc8c726b7208ed99e790b61a5c19bf91faccc08580da63074b7745bf8cb41c70100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000830a0259e0a8306a4faa80f095fe2be0ea6d367f5a4d55b6af92cb0c301ec31e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c741cbf85b74b77430a60d5808ccac1ff99bc1a5610b799ed98e20b726c7c8fde15efee5b076fff4a7f14c807acf3ff1f4b15b20ac6922202d29a17007b7a0083a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29285d025d86d4601d48b22afbc797ce307cf9f9954cc9a26688b33b82864764a37a0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000003c44db9e744369bc46bfdda0d2a17b9adf0d4d3f88c788998316d850f86429f000000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007aa3644786823bb38866a2c94c95f9f97c30ce97c7fb2ab2481d60d4865d025d62b3bd30f926aa46700451aee013eb71e4d025f5d99b08b3467a413681074fa03a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280b2ea55ed75618593731a18109566e17bb3d47ac9bed52a43603dd88a1a0b7db0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000c27e1d80d70965969152c9a88978d93eb00494fbc0f2f38589be86b6b0274e600000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200dbb7a0a188dd0336a452ed9bac473dbb176e560981a13137591856d75ea52e0b4eb940b1e19d2c70b6f271131b861b84559e22971122375fb4a2d925351abbd03a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288e97fd283949bd88d7a1cdb537f96aa3bd4400e428d88c2b3fdd7cc7c262efcb0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000083f7b2b02b459055477255c4145d3bda6b177fbbbcfa128a961512ec911d24b800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502be000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200cbef62c2c77cdd3f2b8cd828e40044bda36af937b5cda1d788bd493928fd978e985fb6ddd770245132cfe8aace771c50a9b32fc4ce99ee542ac1fb7fe869dbb33a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928bf9e162020d124dacd9a96279f12dcdb594cc92f75c58956643706081f1e775a0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004ba9fadfa26c0beeeceec794bb9302b817d0076c3676b93bca33d0a1ae16c1d900000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502bf000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005a771e1f080637645689c5752fc94c59dbdc129f27969acdda24d12020169ebffc3933f54a84d41f6313d86f9a089b49294e69c5c3e2c32b8360dd4623cd29b23a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f87057724656d5654bb11ee92df11fcabe00883e5f93896ead4f0817dc087b550100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009ca72182136a6f126ab59482bf1387a6d56b24165c861612a3d0e78e648e98fd00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200557b08dc17084fad6e89935f3e8800beca1ff12de91eb14b65d55646725770f8558fe844dcec51556b37c48e5753005400ec57559876d4d66a796c8a1341ba823a4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292837c65433f088aada1ad54b6e7e5ac04735137e373c2fcb0e00238cfc78af19b90100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fb72a7b97780fd8f61c929646c65b4e52ba9e434cdf9db9e29904e7579d0379400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200b919af78fc8c23000ecb2f3c377e133547c05a7e6e4bd51adaaa88f03354c637fac2c3745960a97fc07997190021ed99ae6689e121b5f4ad1d2d1b56d68652653b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ef0b63af0b85d492d1f0af357b4fbb849e0926705dde821a9c2ac5a15621bbdb0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000090f4e91d5059d5e109fcf4ff9809ef3ccc4889576774fde6ea1bfcad8f1f8c8400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200dbbb2156a1c52a9c1a82de5d7026099e84bb4f7b35aff0d192d4850baf630bef94367983f4543a46c57ab507e2d027b682353d9132cc6edfbd089dc6275b9ae63b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928683364d7ffb58f590fe07a74de9207ea0409b11931c5d3e189ab4a5ded5b55740100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ac358a356ec0ed3736c26386ae08b6553a65e28c772db715d04a005a3e12190e00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620074555bed5d4aab89e1d3c53119b10904ea0792de747ae00f598fb5ffd764336890316e67b02d67d70958429ae177ef262008f92aa5d0e6e5f735b929e5c1b8c03b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ab2f851193d27c28f73f63be37315b3f42f32ed8ed6c9721cf802fe6439056530100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d43074f6b4cc11055dd1be589f204332f6488f0facd48776576457730254309a00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620053569043e62f80cf21976cedd82ef3423f5b3137be633ff7287cd29311852fab9533d6cbb5f35e76e002cea279f4e4e8fe1af1926a989d00e127f5c15978246b3b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ccee58293b27827a09c71810152e942bb0974c62d4925cce6e86144f0f84bd550100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000093d59210c8e3dbaec12a61fdbf5432504782355d9a5ff676486f660a72f688b800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620055bd840f4f14866ece5c92d4624c97b02b942e151018c7097a82273b2958eecc7164b3697c531927572aea4fa63de2879aed2a00b07213043f4712abf902d9683b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928cf4bbea1f52414a9c8f6469dfd794e78fd3495fe58b4b8cb46e6de2852546bef0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000075944f7e9163e986bf4bf950016801ea265a3ec4fb4e8b6dc602ae5942c7516200000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ef6b545228dee646cbb8b458fe9534fd784e79fd9d46f6c8a91424f5a1be4bcfb68897bb13e0a0ebd18a3f92a76f81965c2e81bdcc20f92b1a8d8bc9899a15693b4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a380e8924e5b6cb90ba81cd4cc3c61904e4162755dd5f5e7fd81521fc4a3e8f80100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000122cd1bcbaf84766803b99c1b02d1ebba9aa44f8c05d1f6b791d9a244778d28a00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f8e8a3c41f5281fde7f5d55d7562414e90613cccd41ca80bb96c5b4e92e880a3569c73485915f33ef3c6795dc749c32efe5c7cf06691138dbeefd3c397e232f63c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a50280f06ab7db0bad12f77e459fe6f1b8f78ca9fde530fe533dd71b32b2ef740100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000071ab3fc060763ac9b454161e4e6c0744759cce6a73ec948b2c4cc0d6cf6c7df300000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620074efb2321bd73d53fe30e5fda98cf7b8f1e69f457ef712ad0bdbb76af08002a55537689b9402606742880c99467d80a3011e5d216bf1935cb620e86073dafbba3c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928dac59200abf7ebe703d8264bed9b4ff1d5d8df5bbc436577b1ae7c6d39eaad350100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d3ab8a1194af69352b6d434622e78ee9e155f7cbcc86059aa4ea1fab403966b600000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502c9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620035adea396d7caeb1776543bc5bdfd8d5f14f9bed4b26d803e7ebf7ab0092c5da1a4755f38b40258a403d609ea254780e21b2b8f7c46e4b768dda2a017bec6a6c3c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292848e909360e6b764e3661952a022f6f66e2fe41d6faccb800d9b6da428d43fcf50100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008a9808b1b7a4eb8a48be502c476ee2f6f106e09b97c9767ef35cf226109e99c900000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ca000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f5fc438d42dab6d900b8ccfad641fee2666f2f022a9561364e766b0e3609e9483103241fc430bbd2884612603b234a0bc3b186ba43100f6111a8883b36c547cc3c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281fa639915dac85b409f150f4c820bb54eb2d734a99e418c42990377abae8d2280100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d0cb78993acae552341f8cf397b3a77bbfaef2b131a70ee79e0512ea42f7aea000000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620028d2e8ba7a379029c418e4994a732deb54bb20c8f450f109b485ac5d9139a61f251479ff104d6e2be0cbaa15ca4ab0b32f4edf4173c3ca7c9a1905dabd9edec43c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b3161fe7ff7b08562dab65bf6a5e3504e63066d3b72f762a6d5bdeae9522bcd70100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007ffe6e423455defc1a893cbe7e604fb208e689d8523077e39111c741e366a30b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d7bc2295aede5b6d2a762fb7d36630e604355e6abf65ab2d56087bffe71f16b34850edd5901cd508b04186bb25cb5c77506952512d21538bdcb53524154d36503c4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283859db07ce79bb9ea6644fe4ab83de37d26d9970595c7572527e2871680b7f780100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000593e808afcfd048d0060dff90a2f9b9411cf976568e4d0a3a0c467051a37e5c800000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200787f0b6871287e5272755c5970996dd237de83abe44f64a69ebb79ce07db59388966be6e29df64a1c010f885b07766c5e8503d5fbc40d145c765fb78cc97fbb93d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928c319368c69829d6c02e86021c83fcaa55c27ec2a0d17d67e02f003a7c5a842900100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000517ca61708fb65289ec55df8471392341c1f9aded59c338785aeadaa3da4ac1000000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ce000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009042a8c5a703f0027ed6170d2aec275ca5ca3fc82160e8026c9d82698c3619c35168b8f052c9366c58a36c3bf5a8f1e51f39b0400e90f8f068a7b8be2e26d8a03d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928003b70332145cf3fe157051391f5a89c28c67296fe3cceff35b41e2746f1672c0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c4dbc9a8175bdf8bbc000bd9ac6fb1d576822832d98b62d8899b6a5e60bebd9100000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502cf000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002c67f146271eb435ffce3cfe9672c6289ca8f591130557e13fcf452133703b002ed07d4f9ee6671da5c5336971e9df635cfce248b619bee91489e95aaa3d7fe83d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a8116b612d75df8413a1b70399547539a2858bc3989423a86aba93aee537109a0100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000066dae350813cad94f1109195102dbb6d81c1a6c9b4b7b838c6d5b776710191da00000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009a1037e5ae93ba6aa8239498c38b85a23975549903b7a11384df752d616b11a82cfdc402430c073c23aee439f8c867da53b2eb505a40d82fc68c4657dd2d01e13d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928b200ab67d0b2aaa03e8882b21cd280ed4ca69f873c5a4f77d8aff22fa43ba1c60100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009935c5d65c68231e034204a78846a217304c0773f689df9218887337746ddc1200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c6a13ba42ff2afd8774f5a3c879fa64ced80d21cb282883ea0aab2d067ab00b2eece4998904520b6b53bd380d6fb41567ef59e39a392b3116c7ba42635679eb13d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928df46033d08d36d9acd0858d145e1af29bcd53589bc60fdd78b65814acfcab2880100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ed85d91397b0df894ce95c3b3de0f7058f4d7982b7ccb1202424e1770d571b3c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620088b2cacf4a81658bd7fd60bc8935d5bc29afe145d15808cd9a6dd3083d0346dfea4a403a8d189c98280d2e2a3c9152594b9a0314a951b08c4fbcd11c281cf0de3d4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292828d0f223c4c8e3149c0ade234ee313c84992fb3d5bb015c86f44d3d5f2adf6420100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e85d59908fc13b7f0e0bd5b4e9ecf110f8a09c3e558f3f8ec910c0b75f8f2bd800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620042f6adf2d5d3446fc815b05b3dfb9249c813e34e23de0a9c14e3c8c423f2d028591cbc1a4fcc14478fc218fac1446ba588df192eade9e7f030d654232cf2fdd03e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e5e518f553a5853cabc78c41cf98d68a1ab4d1e3c23f0ad0f4a6cddedd0f96e50100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000edc4056b4adfc011726ae506242f6e0e053535027e7b1b36578b271c433afe3e00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200e5960fdddecda6f4d00a3fc2e3d1b41a8ad698cf418cc7ab3c85a553f518e5e5cd16510070366fcdd6bed19d4bd0be327bdd1fbeb0fa1bd8bac5b454227e079e3e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292844eb2c76d8de3add5465df073ab207af667a2d7d50ea156dda621d34e3e045da0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e08245a57f07eaf6a24874defb3619fc949e9c2c088a12ddc97e5abab398ca1400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200da45e0e3341d62da6d15ea507d2d7a66af07b23a07df6554dd3aded8762ceb4458b7d15a90d881b159f31f7304d82a7512ff88d90f16501296f57d88ae4449943e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928061e4df5638e489dffeaba7f638141fcf1242c69be5684206411232c9ab659290100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000679672eb00151fb9600061f443346f21980b714d6fcb8f08f6a09d461797e34200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002959b69a2c231164208456be692c24f1fc4181637fbaeaff9d488e63f54d1e069c8baea43ccce4ee6af92d8b857674fc667015c460e13452208b7d09c73137f73e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928c740194b29dc5481f95bdc804cd17b63014f51163b45949c674cc3fa19c0a7fc0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008364cf36586acd0e670a7d9ff49f7d3ce12af63048d270a8a541a8eb444e9c2100000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200fca7c019fac34c679c94453b16514f01637bd14c80dc5bf98154dc294b1940c70dad8fe0de448c110669a728d968c66b957b78a667099a5189d8efc51541ffb93e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292831d8c28be6184da3973e0187b572f5550320677710dae9e3ecaa903f4ae202ac0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008b5ff481cf3480112720330071c7da7d3e621de2613d53af491807b60809f8c000000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ac02e24a3f90aaece3e9da107767200355f572b587013e97a34d18e68bc2d8317ce6c8011ed9fc8abb2d6d98cd1eab86470f631ac51dd9416ae1799aa0a491183e4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a33b23c79a29a0713cead3247c26899a591e71f144443c548e8b464d8a4305280100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000bb27179da94a8aef1500ccfacdd8c98a7d04b53c7206368401f8d03c1b91e28900000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502d9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162002805438a4d468b8e543c4444f1711e599a89267c24d3ea3c71a0299ac7233ba38d86ae8ec7e9a1376300035c2959e1d81f87e015838ca8d682c2f1eabefdcf193f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292825e3c5fbce118d59ec4a31b84ba5c7f8da784f37f7efa48ef8cbeddbdb01618a0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000fab5d284b76ccaca03a10d66334271abe4e97189a6c8deda768805d10b1e84f000000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502da000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162008a6101dbdbedcbf88ea4eff7374f78daf8c7a54bb8314aec598d11cefbc5e3254638b041ce64dab4df93ea1bbae55fa9599d19ede54fdd79755379e263eec7ff3f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280e2596e540d5ab2c106399de93c1898227e0b517fd930bffbdcf833cf7b2af600100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000636f2b033c7833bc54d627434c6d8bef56b9427bef0cbe5aeb9a58195fd599800000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502db000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620060afb2f73c83cfbdff0b93fd17b5e0278289c193de9963102cabd540e596250e77cbee33d997369f5553f3be22ac56556e9204633730abc3f47ec2512da1e1fc3f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29286b9f91b4bd3ec7b6fb2687e3a8af6910f51d5b200375f632f1c0b3821fcf95ac0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000009b3f4f8a16be976df748a525780b21f990eeb74cf976cd43f2274b8463f0454500000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502dc000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200ac95cf1f82b3c0f132f67503205b1df51069afa8e38726fbb6c73ebdb4919f6bd0ff5e40dac29df059a5dde0ab2316e702b589b1ac703e43300c3a94648f0b513f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928161335a7077b0fcc6db4c37fbeee4abfb4a0628a1fe5e2ecd83dd51f0034bd3b0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000971cce9e7ab4f7d5b0bb20d989bf62cb9a881c2b1dc848110fe90b03402dd5ec00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502dd000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162003bbd34001fd53dd8ece2e51f8a62a0b4bf4aeebe7fc3b46dcc0f7b07a73513160eab96c964fa9c16764929e734f497a36a56d3ad361f5afdcf08cb55dc03ba753f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292871e33428d14c8af5efd5c794b67e14c0db64da18269f5e19725955d36c0b73d10100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e01ba87a73b93fc0535d8089c4aca557635c3d00a2bf8a82df14508f2e23865d00000000000000000300000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502de000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d1730b6cd3555972195e9f2618da64dbc0147eb694c7d5eff58a4cd12834e3717e98fcd8ff229ede4e78d29e388e252a6603cb7fe2433a07da69069d636487b83f4ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f971afd3c7376a78cc651c063aff15e9da6801f341c538e11b53c51adb094ff40100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000a3f235f53f425c48b7df3834fad36eb71566867e50f2c9f1723c02a2402e53400000000000000000200000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502df000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200f44f09db1ac5531be138c541f30168dae915ff3a061c65cc786a37c7d3af71f9fc3afc2548cae1e2b3f450c092bb9ba2ff868aadd254078975e7bf020eb2d409404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928db03c1678d6ed558d0351f9365f9e29f09ed6d4b5f66610a527ed532aa77bfc60100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000007f621be5356058841a5db700649163d6f9ad59f7f818b772b52374efd1f4954b00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c6bf77aa32d57e520a61665f4b6ded099fe2f965931f35d058d56e8d67c103dbbddfff5200cfaf0fa1fd1b35bf7266e3216be329506df9943d8d686b6721e9d9404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928828c8b99c57df6e6b5ec9cbb195d345c2ca5859e4a5d3460e56eba99ec0c569d0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000002f46e38a9af4fff05923743a9a8793732b9a10c07c36f1282d0b77befffcd12a00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009d560cec99ba6ee560345d4a9e85a52c5c345d19bb9cecb5e6f67dc5998b8c828ea59fb37ece037c6718e393aaf1ab16a89499d9349e19eecbb8f9bd0aac748f404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29280b384489b861ded7beef9c2f70332c0640de85f0aa92d5b987af715e30ac38490100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000822ca096ab2725d4c855ae0f104e4f52ee8336f876c62fa4ea3a488ed016d6d200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e2000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162004938ac305e71af87b9d592aaf085de40062c33702f9cefbed7de61b88944380bc43fd8902c131b167637b0064c4757e77e450d9f868f5f9e101e4deacae1dbb6404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29285e8e725b384d9251f462dbe8fb89712464444e5d8239a82f8fb147a89a9175500100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000006811a0692d6f4fc4df3e4bb0148a80a2038585c76a8286235c3537ccf3057ab900000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e3000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005075919aa847b18f2fa839825d4e4464247189fbe8db62f451924d385b728e5e7b172489c5d534624486077eddfc7ed2a9ca329e1d5afdb335b074e439dd6770404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928f5b13f44ad4d7737666792159d5b1bf538c63a2a9850d73893ceac682c4226640100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000055b93338f1670b9eea0f11d6d71003730248a7e5ae63c3ec23e3d4dbde56810400000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e4000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006426422c68acce9338d750982a3ac638f51b5b9d1592676637774dad443fb1f5fdfbdc260644b48417db682b79b5ac9b1db5fb407d69e0212809ea9336f4823a404ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29281fcf82d6561c08b6d06603a1c2a4248955ea5d2f2003f37eb33d0a2f5e57cc960100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d52801a28b1668b799980e23ced579f8737bbb94d9fd1b5b7df0241cc388884a00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e5000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0401620096cc575e2f0a3db37ef303202f5dea558924a4c2a10366d0b6081c56d682cf1f733b99746ee70646479cde411fd45dae66a43c7e3b69477c659e7d6bc02c1a4c414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282b873b407bfce06db5a292a76a27a993070adba1b1d28662de19fd0e64ca17c30100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000008c2ec0f391b1dca1b09f7cce93c9cec586974c2a87bd3ac05cf7df9f72edd8c200000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e6000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c317ca640efd19de6286d2b1a1db0a0793a9276aa792a2b56de0fc7b403b872bdcaef26a599b3a5cd11e73843a8f9a584a3cfc2a7b3792ff7874a0c99fcf6ed4414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29288c0193613a6c45ea1ac343f0e3a748ff2a54430a4f0e3b51aa3da8ed9590ed5a0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000519866e8fbf900a658e203a1cfbde1d5c587c40624fe278218cf99fd57ca553400000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e7000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162005aed9095eda83daa513b0e4f0a43542aff48a7e3f043c31aea456c3a6193018cecdcf65a15ae59b79a34cc646af05ca4248ee339ab25c645f447af7fbd8fe3a3414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928bf9b8f39c0d825e4d245b56fcd3f74c9e1bac414878be812950009fd5c0601da0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b17c1cd916397760360b0e2886434183645e39ccc507ade4b9b74f161301735b00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e8000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200da01065cfd09009512e88b8714c4bae1c9743fcd6fb545d2e425d8c0398f9bbfc4f166844a81190b293ffd06a9789ea7b66802e1ca8388ffd5a83a5879e1459b414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292854730ea68411b68765bb6e608e5c5b7b3e3b9c37dd2b6266ddd7a8f331610a350100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000004b4376a71652a3c9be7be0963dbee82c3da8d1da9f52d762320358bb18f8ac2900000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502e9000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200350a6131f3a8d7dd66622bdd379c3b3e7b5b5c8e606ebb6587b61184a60e735445c4f1bf971cb53035e032e2d784c1da0e211364fc9351b7977b4ccf48b5fb1f414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29282184fb69fc26955e2a1fc0cf5f6afb00aeca2482ad651122de34efd66394196c0100000000000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000b7094b2eb7cda4f9c240b87dd917b994715942925a9fde30a4d81b5fd8b4a0900000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ea000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162006c199463d6ef34de221165ad8224caae00fb6a5fcfc01f2a5e9526fc69fb8421115736c4113735ac0f62718248620ba7f95ca93af71b8cfa45d2a1df755176ce414ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928bd96a50e897f90caf8b99c6ef61b6649ef41758f26e05e5c3b8c31bee4be4a030100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000f1291196d3f952b8442f1e65ca518c9a368eba2dac19c893035e0e67e13a9faa00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502eb000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200034abee4be318c3b5c5ee0268f7541ef49661bf66e9cb9f8ca907f890ea596bd1f09e0d3b7bc86448f56bbb91da01b1f6c6f1a69c8f8c8b7243500ad587ce2ab424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ac5d9a5f35bb915993a621f19cc603673900f77667c408c96f7500527c1acfd80100000000000000ffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000073c037fc147f7a3fcef38f0504474d09b66feb09de81fa8e6b65bc1346ad3b4100000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ec000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200d8cf1a7c5200756fc908c46776f700396703c69cf121a6935991bb355f9a5dac3fef800f3fd29f1cc70a947e55520a6dba4ceaa8a7cd72fbc89e46c7b485f4d0424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928ee23cbce9a5de215e779571b2775a9c71d1d8159da4026a7baeb0596a42c397b0100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000a3d01254671f80b184c8d62911011faa08e0c06b1d65dbc3340776dd71e469ec00000000000000000100000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ed000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162007b392ca49605ebbaa72640da59811d1dc7a975271b5779e715e25d9acecb23eea5ea9d0163a939caeed2ce52cc1de19fe3cd1bb064b3d112052a19ebf57d7579424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292871f7accba859626882f604842ceb646b93560830d2d9e4b446daa3d537fac4c70100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000c0496135e0f611659da04d3f33f87a93a2c00b94b02757a34a8724c8ff105bdf00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ee000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c7c4fa37d5a3da46b4e4d9d2300856936b64eb2c8404f682686259a8cbacf771301bcfdd191bbd6fdf4c72ddeda4347657eae25a6811fb1026e0139126565be6424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928a8a364c58eadd7af0565cc5569e259627bb200ed40b3432fc75e834248396a530100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000e2259d37de910d4204ea3828a1f04529ec28bd990ef1a2f1d88c409b238583f800000000000000000600000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502ef000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200536a394842835ec72f43b340ed00b27b6259e26955cc6505afd7ad8ec564a3a8cd4592844daec828f91fe58c1e1fde74ffce76c43cf3e78bea062d8240ce4bd9424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff292848e6cb452a13e5e0e2bf9568b428e4df200d122215ecb2661708082f61da6ac90100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000b249f56fa6d0ee051fc0c4d6da52782c24aec71315f8f921eeb703185b2e8d6c00000000000000000000000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f0000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "04016200c96ada612f08081766b2ec1522120d20dfe428b46895bfe2e0e5132a45cbe64830dd83d58a60c832ba3b439fb46347aeed5abcec290f85eb97b8084981e1f998424ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff29283fdded83f26b74c905a21994c3f7cfa2bbc8116bedc70a8ed0ac6e815c5802950100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000ca7c0b578a91c35ad817cda2469dea43e19809d2070c86a274669967cdd4be6a00000000000000000400000001020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f1000101ffffffff0200901ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000",
+    "040162009502585c816eacd08e0ac7ed6b11c8bba2cff7c39419a205c9746bf283eddd3f5f8dc1a142875b05555e6114378c3c893d5c7a1fed5b5645b8785dbeb5d1824c434ae75affff7f200000000002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2928e4613937c4de20c396f69861a05b53aa2621dc7c40d801f0d833dc79f37143980100000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000d020187a8113525501b8228f419e565130fe9ac32e6a9611d12c817d98d70e9100000000000000000200000002020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0502f2000101ffffffff0258a11ec4bc1600001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ed7fd62132d78b82a547057b19129134e1bca0096ff2b37bac67bb16c8e53d59ec01200000000000000000000000000000000000000000000000000000000000000000000000000200000001b40e4032e98eaddd01559da7cf829651ce78602c8bed0c8eb96d74d1a7a9db71000000006a4730440220264fb45ef7a2449ba6e74c332dc451d42e06b86532b2cc1c691fa42efa1c7ebd0220490b718c1c482bdc7cfdd05b620bd930a3b01613dfcdbea5a6f4a7c414c0faf801210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3ffeffffff02a88e724e180900001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0080ca39612400001600147a55db003ae0c1da82427c119a35df58352ad1e4f1000000",
+    "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"
   ],
   "mocktime": 1525107225,
   "stats": [
@@ -251,7 +251,7 @@
       "avgfee": 0,
       "avgfeerate": 0,
       "avgtxsize": 0,
-      "blockhash": "f7ced2893209aebd6f34ab898c52b3666a4413dd79968e755829e6c267528512",
+      "blockhash": "3fdded83f26b74c905a21994c3f7cfa2bbc8116bedc70a8ed0ac6e815c580295",
       "feerate_percentiles": [
         0,
         0,
@@ -288,7 +288,7 @@
       "avgfee": 4440,
       "avgfeerate": 20,
       "avgtxsize": 222,
-      "blockhash": "d042ea72e04bba9628c71935cd3f25ba8f5be24fd03c2f9191bb7482ca63006d",
+      "blockhash": "e4613937c4de20c396f69861a05b53aa2621dc7c40d801f0d833dc79f3714398",
       "feerate_percentiles": [
         20,
         20,
@@ -325,7 +325,7 @@
       "avgfee": 16320,
       "avgfeerate": 113,
       "avgtxsize": 225,
-      "blockhash": "452be0bdde2d0d6bbcfb4a351dad10a479a216af53a14169ddae1734b1cb8872",
+      "blockhash": "69fa2f237f6d8529f58cc1448947b8705f186d455f93a351d2e13057c2d68869",
       "feerate_percentiles": [
         20,
         20,
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index f4fe29871a3..08319fa7fd4 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -22,6 +22,7 @@
     hex_str_to_bytes,
 )
 
+from test_framework.auxpow_testing import mineAuxpowBlock
 from test_framework.messages import BLOCK_HEADER_SIZE
 
 class ReqType(Enum):
@@ -205,8 +206,9 @@ def run_test(self):
         long_uri = '/'.join(['{}-{}'.format(txid, n_) for n_ in range(15)])
         self.test_rest_request("/getutxos/checkmempool/{}".format(long_uri), http_method='POST', status=200)
 
-        self.nodes[0].generate(1)  # generate block to not affect upcoming tests
+        mineAuxpowBlock(self.nodes[0])  # generate block to not affect upcoming tests
         self.sync_all()
+        bb_hash = self.nodes[0].getbestblockhash()
 
         self.log.info("Test the /block, /blockhashbyheight and /headers URIs")
         bb_hash = self.nodes[0].getbestblockhash()
@@ -228,9 +230,10 @@ def run_test(self):
 
         # Compare with block header
         response_header = self.test_rest_request("/headers/1/{}".format(bb_hash), req_type=ReqType.BIN, ret_type=RetType.OBJ)
-        assert_equal(int(response_header.getheader('content-length')), BLOCK_HEADER_SIZE)
+        headerLen = int(response_header.getheader('content-length'))
+        assert_greater_than(headerLen, BLOCK_HEADER_SIZE)
         response_header_bytes = response_header.read()
-        assert_equal(response_bytes[:BLOCK_HEADER_SIZE], response_header_bytes)
+        assert_equal(response_bytes[:headerLen], response_header_bytes)
 
         # Check block hex format
         response_hex = self.test_rest_request("/block/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
@@ -241,8 +244,9 @@ def run_test(self):
         # Compare with hex block header
         response_header_hex = self.test_rest_request("/headers/1/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
         assert_greater_than(int(response_header_hex.getheader('content-length')), BLOCK_HEADER_SIZE*2)
-        response_header_hex_bytes = response_header_hex.read(BLOCK_HEADER_SIZE*2)
-        assert_equal(binascii.hexlify(response_bytes[:BLOCK_HEADER_SIZE]), response_header_hex_bytes)
+        response_header_hex_bytes = response_header_hex.read().strip()
+        headerLen = len(response_header_hex_bytes) // 2
+        assert_equal(binascii.hexlify(response_bytes[:headerLen]), response_header_hex_bytes)
 
         # Check json format
         block_json_obj = self.test_rest_request("/block/{}".format(bb_hash))
diff --git a/test/functional/rpc_dumptxoutset.py b/test/functional/rpc_dumptxoutset.py
index 830c81e0cca..74914aaea15 100755
--- a/test/functional/rpc_dumptxoutset.py
+++ b/test/functional/rpc_dumptxoutset.py
@@ -37,13 +37,13 @@ def run_test(self):
         #           This is presumed safe none of this code changed, so we're updating the value for future changes to test against.
         assert_equal(
             out['base_hash'],
-            '84eeddf68cf159e2a60a8bb45e99e835e2191b80fff8fb002bf3d27e87b81e66')
+            '2913351cb7800340861d0b15c8a8b53e1f16f3618c8f10feba919232c794f44a')
 
         with open(str(expected_path), 'rb') as f:
             digest = hashlib.sha256(f.read()).hexdigest()
             # UTXO snapshot hash should be deterministic based on mocked time.
             assert_equal(
-                digest, 'c5839e03f6c15c5eb0cdf952324636e5feb1b5c6095cbcddde8dcdbea5696d54')
+                digest, 'b90833d336487f7d577a8f2153701cc40dd44141b9a861ddd39dbe96c6794218')
 
         # Specifying a path to an existing file will fail.
         assert_raises_rpc_error(
diff --git a/test/functional/test_framework/auxpow.py b/test/functional/test_framework/auxpow.py
new file mode 100644
index 00000000000..c601147b4b0
--- /dev/null
+++ b/test/functional/test_framework/auxpow.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# Copyright(c) 2014-2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Basic code for working with auxpow.  This is used for the regtests(e.g. from
+# auxpow_testing.py), but also for contrib/auxpow/getwork-wrapper.py.
+
+import binascii
+import codecs
+import hashlib
+import ltc_scrypt
+
+def constructAuxpow(block):
+  """
+  Starts to construct a minimal auxpow, ready to be mined.  Returns the fake
+  coinbase tx and the unmined parent block header as hex strings.
+  """
+
+  block = codecs.encode(block, 'ascii')
+
+  # Start by building the merge-mining coinbase.  The merkle tree
+  # consists only of the block hash as root.
+  coinbase = b"fabe" + binascii.hexlify(b"m" * 2)
+  coinbase += block
+  coinbase += b"01000000" +(b"00" * 4)
+
+  # Construct "vector" of transaction inputs.
+  vin = b"01"
+  vin +=(b"00" * 32) +(b"ff" * 4)
+  vin += codecs.encode("%02x" %(len(coinbase) // 2), "ascii") + coinbase
+  vin +=(b"ff" * 4)
+
+  # Build up the full coinbase transaction.  It consists only
+  # of the input and has no outputs.
+  tx = b"01000000" + vin + b"00" +(b"00" * 4)
+  txHash = doubleHashHex(tx)
+
+  # Construct the parent block header.  It need not be valid, just good
+  # enough for auxpow purposes.
+  header = b"01000000"
+  header += b"00" * 32
+  header += reverseHex(txHash)
+  header += b"00" * 4
+  header += b"00" * 4
+  header += b"00" * 4
+
+  return (tx.decode('ascii'), header.decode('ascii'))
+
+def finishAuxpow(tx, header):
+  """
+  Constructs the finished auxpow hex string based on the mined header.
+  """
+
+  blockhash = doubleHashHex(header)
+
+  # Build the MerkleTx part of the auxpow.
+  auxpow = codecs.encode(tx, 'ascii')
+  auxpow += blockhash
+  auxpow += b"00"
+  auxpow += b"00" * 4
+
+  # Extend to full auxpow.
+  auxpow += b"00"
+  auxpow += b"00" * 4
+  auxpow += header
+
+  return auxpow.decode("ascii")
+
+def doubleHashHex(data):
+  """
+  Perform Bitcoin's Double-SHA256 hash on the given hex string.
+  """
+
+  hasher = hashlib.sha256()
+  hasher.update(binascii.unhexlify(data))
+  data = hasher.digest()
+
+  hasher = hashlib.sha256()
+  hasher.update(data)
+
+  return reverseHex(hasher.hexdigest())
+
+def getScryptPoW(hexData):
+  """
+  Actual scrypt pow calculation.
+  """
+
+  data = binascii.unhexlify(hexData)
+
+  return reverseHex(binascii.hexlify(ltc_scrypt.getPoWHash(data)).decode("ascii"))
+
+def reverseHex(data):
+  """
+  Flip byte order in the given data(hex string).
+  """
+
+  b = bytearray(binascii.unhexlify(data))
+  b.reverse()
+
+  return binascii.hexlify(b)
+
+def getworkByteswap(data):
+  """
+  Run the byte-order swapping step necessary for working with getwork.
+  """
+
+  data = bytearray(data)
+  assert len(data) % 4 == 0
+  for i in range(0, len(data), 4):
+    data[i], data[i + 3] = data[i + 3], data[i]
+    data[i + 1], data[i + 2] = data[i + 2], data[i + 1]
+
+  return data
diff --git a/test/functional/test_framework/auxpow_testing.py b/test/functional/test_framework/auxpow_testing.py
new file mode 100644
index 00000000000..e9ccca9dc8c
--- /dev/null
+++ b/test/functional/test_framework/auxpow_testing.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# Copyright(c) 2014-2019 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Utility routines for auxpow that are needed specifically by the regtests.
+# This is mostly about actually *solving* an auxpow block(with regtest
+# difficulty) or inspecting the information for verification.
+
+import binascii
+
+from test_framework import auxpow
+
+def computeAuxpow(block, target, ok):
+  """
+  Build an auxpow object(serialised as hex string) that solves
+  (ok = True) or doesn't solve(ok = False) the block.
+  """
+
+  (tx, header) = auxpow.constructAuxpow(block)
+  (header, _) = mineBlock(header, target, ok)
+  return auxpow.finishAuxpow(tx, header)
+
+def mineAuxpowBlock(node):
+  """
+  Mine an auxpow block on the given RPC connection.  This uses the
+  createauxblock and submitauxblock command pair.
+  """
+
+  def create():
+    addr = node.getnewaddress()
+    return node.createauxblock(addr)
+
+  return mineAuxpowBlockWithMethods(create, node.submitauxblock)
+
+def mineAuxpowBlockWithMethods(create, submit):
+  """
+  Mine an auxpow block, using the given methods for creation and submission.
+  """
+
+  auxblock = create()
+  target = auxpow.reverseHex(auxblock['_target'])
+  apow = computeAuxpow(auxblock['hash'], target, True)
+  res = submit(auxblock['hash'], apow)
+  assert res
+
+  return auxblock['hash']
+
+def getCoinbaseAddr(node, blockHash):
+    """
+    Extract the coinbase tx' payout address for the given block.
+    """
+
+    blockData = node.getblock(blockHash)
+    txn = blockData['tx']
+    assert len(txn) >= 1
+
+    txData = node.getrawtransaction(txn[0], True, blockHash)
+    assert len(txData['vout']) >= 1 and len(txData['vin']) == 1
+    assert 'coinbase' in txData['vin'][0]
+
+    addr = txData['vout'][0]['scriptPubKey']['addresses']
+    assert len(addr) == 1
+    return addr[0]
+
+def mineBlock(header, target, ok):
+  """
+  Given a block header, update the nonce until it is ok(or not)
+  for the given target.
+  """
+
+  data = bytearray(binascii.unhexlify(header))
+  while True:
+    assert data[79] < 255
+    data[79] += 1
+    hexData = binascii.hexlify(data)
+
+    blockhash = auxpow.getScryptPoW(hexData)
+    if (ok and blockhash < target) or((not ok) and blockhash > target):
+      break
+
+  return (hexData, blockhash)
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 576c47182bf..edae2df49cd 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -290,6 +290,13 @@
     'p2p_permissions.py',
     'feature_blocksdir.py',
     'wallet_startup.py',
+
+    # auxpow tests
+    'auxpow_mining.py',
+    'auxpow_mining.py --segwit',
+    'auxpow_invalidpow.py',
+    'auxpow_zerohash.py',
+
     'feature_config_args.py',
     'feature_settings.py',
     'rpc_getdescriptorinfo.py',
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 6bd02d45ace..38a26589f9a 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -21,6 +21,16 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "wallet/fees -> wallet/wallet -> wallet/fees"
     "wallet/wallet -> wallet/walletdb -> wallet/wallet"
     "policy/fees -> txmempool -> validation -> policy/fees"
+    "auxpow -> primitives/block -> auxpow"
+    "chain -> validation -> chain"
+    "dogecoin -> pow -> dogecoin"
+    "rpc/blockchain -> rpc/rawtransaction -> rpc/blockchain"
+    "chain -> validation -> consensus/tx_verify -> chain"
+    "chain -> validation -> dogecoin -> chain"
+    "chain -> validation -> pow -> chain"
+    "chain -> validation -> txdb -> chain"
+    "chain -> validation -> validationinterface -> chain"
+    "chain -> validation -> versionbits -> chain"
 )
 
 EXIT_CODE=0

From 6069d14a67c175595ed8609c4cb3fdea25126155 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <jrn@jrn.me.uk>
Date: Sat, 11 May 2019 22:42:51 +0000
Subject: [PATCH 3/4] Replace consensus values with Dogecoin equivalents

* Replace chain parameters with Dogecoin values
* Update maximum coins to match Dogecoin
* Disable version 2 block requirement
* Update coinbase maturity to match Dogecoin
* Disable SEGWIT bit in protocol announcement.
---
 src/protocol.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/protocol.cpp b/src/protocol.cpp
index 55261984c6d..6dac3924b2c 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -136,9 +136,13 @@ bool CMessageHeader::IsCommandValid() const
 
 ServiceFlags GetDesirableServiceFlags(ServiceFlags services) {
     if ((services & NODE_NETWORK_LIMITED) && g_initial_block_download_completed) {
-        return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
+        // Dogecoin: Disable segwit
+        // return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
+        return ServiceFlags(NODE_NETWORK_LIMITED);
     }
-    return ServiceFlags(NODE_NETWORK | NODE_WITNESS);
+    // Dogecoin: Disable segwit
+    // return ServiceFlags(NODE_NETWORK | NODE_WITNESS);
+    return ServiceFlags(NODE_NETWORK);
 }
 
 void SetServiceFlagsIBDCache(bool state) {

From 39f13f6cdca910471415c626a4fa312ac60cd8fc Mon Sep 17 00:00:00 2001
From: Ross Nicoll <jrn@jrn.me.uk>
Date: Sun, 31 Oct 2021 19:52:45 +0000
Subject: [PATCH 4/4] Update strings to Dogecoin

---
 src/bitcoin-tx.cpp                        |  4 +-
 src/init.cpp                              |  4 +-
 src/key.cpp                               |  2 +-
 src/qt/addressbookpage.cpp                |  4 +-
 src/qt/askpassphrasedialog.cpp            |  4 +-
 src/qt/bitcoingui.cpp                     |  4 +-
 src/qt/bitcoinstrings.cpp                 |  7 +-
 src/qt/coincontroldialog.cpp              |  2 +-
 src/qt/editaddressdialog.cpp              |  2 +-
 src/qt/forms/modaloverlay.ui              |  4 +-
 src/qt/forms/openuridialog.ui             |  2 +-
 src/qt/forms/optionsdialog.ui             |  6 +-
 src/qt/forms/overviewpage.ui              |  4 +-
 src/qt/forms/receivecoinsdialog.ui        |  2 +-
 src/qt/forms/sendcoinsdialog.ui           |  4 +-
 src/qt/forms/sendcoinsentry.ui            |  6 +-
 src/qt/forms/signverifymessagedialog.ui   | 10 +--
 src/qt/guiutil.cpp                        |  2 +-
 src/qt/intro.cpp                          |  6 +-
 src/qt/paymentserver.cpp                  | 10 +--
 src/qt/sendcoinsdialog.cpp                |  2 +-
 src/rpc/blockchain.cpp                    |  4 +-
 src/rpc/mining.cpp                        |  8 +--
 src/rpc/misc.cpp                          | 18 ++---
 src/rpc/net.cpp                           | 14 ++--
 src/rpc/rawtransaction.cpp                | 12 ++--
 src/rpc/util.cpp                          |  4 +-
 src/rpc/util.h                            |  4 +-
 src/util/threadnames.cpp                  |  2 +-
 src/wallet/bdb.cpp                        |  4 +-
 src/wallet/rpcdump.cpp                    | 14 ++--
 src/wallet/rpcwallet.cpp                  | 82 +++++++++++------------
 src/wallet/test/wallet_tests.cpp          |  2 +-
 test/functional/rpc_deprecated.py         |  2 +-
 test/functional/rpc_fundrawtransaction.py |  2 +-
 test/functional/wallet_basic.py           |  6 +-
 test/functional/wallet_labels.py          |  2 +-
 test/functional/wallet_send.py            |  2 +-
 38 files changed, 138 insertions(+), 135 deletions(-)

diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 7e4bb06c70f..4a826600ae1 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -98,8 +98,8 @@ static int AppInitRawTx(int argc, char* argv[])
     if (argc < 2 || HelpRequested(gArgs)) {
         // First part of help message is specific to this utility
         std::string strUsage = PACKAGE_NAME " dogecoin-tx utility version " + FormatFullVersion() + "\n\n" +
-            "Usage:  dogecoin-tx [options] <hex-tx> [commands]  Update hex-encoded bitcoin transaction\n" +
-            "or:     dogecoin-tx [options] -create [commands]   Create hex-encoded bitcoin transaction\n" +
+            "Usage:  dogecoin-tx [options] <hex-tx> [commands]  Update hex-encoded dogecoin transaction\n" +
+            "or:     dogecoin-tx [options] -create [commands]   Create hex-encoded dogecoin transaction\n" +
             "\n";
         strUsage += gArgs.GetHelpMessage();
 
diff --git a/src/init.cpp b/src/init.cpp
index 31f5ae7d422..007809b9752 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1333,9 +1333,9 @@ bool AppInitMain(const util::Ref& context, NodeContext& node, interfaces::BlockA
     // Warn about relative -datadir path.
     if (args.IsArgSet("-datadir") && !fs::path(args.GetArg("-datadir", "")).is_absolute()) {
         LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the " /* Continued */
-                  "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
+                  "current working directory '%s'. This is fragile, because if dogecoin is started in the future "
                   "from a different location, it will be unable to locate the current data files. There could "
-                  "also be data loss if bitcoin is started while in a temporary directory.\n",
+                  "also be data loss if dogecoin is started while in a temporary directory.\n",
                   args.GetArg("-datadir", ""), fs::current_path().string());
     }
 
diff --git a/src/key.cpp b/src/key.cpp
index 868a8b9b0e7..e3ad96bb33b 100644
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -234,7 +234,7 @@ bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
         return false;
     }
     unsigned char rnd[8];
-    std::string str = "Bitcoin key verification\n";
+    std::string str = "Dogecoin key verification\n";
     GetRandBytes(rnd, sizeof(rnd));
     uint256 hash;
     CHash256().Write(MakeUCharSpan(str)).Write(rnd).Finalize(hash);
diff --git a/src/qt/addressbookpage.cpp b/src/qt/addressbookpage.cpp
index aa4ec04497a..846b70ffa17 100644
--- a/src/qt/addressbookpage.cpp
+++ b/src/qt/addressbookpage.cpp
@@ -101,12 +101,12 @@ AddressBookPage::AddressBookPage(const PlatformStyle *platformStyle, Mode _mode,
     switch(tab)
     {
     case SendingTab:
-        ui->labelExplanation->setText(tr("These are your Bitcoin addresses for sending payments. Always check the amount and the receiving address before sending coins."));
+        ui->labelExplanation->setText(tr("These are your Dogecoin addresses for sending payments. Always check the amount and the receiving address before sending coins."));
         ui->deleteAddress->setVisible(true);
         ui->newAddress->setVisible(true);
         break;
     case ReceivingTab:
-        ui->labelExplanation->setText(tr("These are your Bitcoin addresses for receiving payments. Use the 'Create new receiving address' button in the receive tab to create new addresses.\nSigning is only possible with addresses of the type 'legacy'."));
+        ui->labelExplanation->setText(tr("These are your Dogecoin addresses for receiving payments. Use the 'Create new receiving address' button in the receive tab to create new addresses.\nSigning is only possible with addresses of the type 'legacy'."));
         ui->deleteAddress->setVisible(false);
         ui->newAddress->setVisible(false);
         break;
diff --git a/src/qt/askpassphrasedialog.cpp b/src/qt/askpassphrasedialog.cpp
index 3d1963b6e64..f0763abf261 100644
--- a/src/qt/askpassphrasedialog.cpp
+++ b/src/qt/askpassphrasedialog.cpp
@@ -116,7 +116,7 @@ void AskPassphraseDialog::accept()
             break;
         }
         QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm wallet encryption"),
-                 tr("Warning: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR BITCOINS</b>!") + "<br><br>" + tr("Are you sure you wish to encrypt your wallet?"),
+                 tr("Warning: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR DOGECOINS</b>!") + "<br><br>" + tr("Are you sure you wish to encrypt your wallet?"),
                  QMessageBox::Yes|QMessageBox::Cancel,
                  QMessageBox::Cancel);
         if(retval == QMessageBox::Yes)
@@ -124,7 +124,7 @@ void AskPassphraseDialog::accept()
             if(newpass1 == newpass2)
             {
                 QString encryption_reminder = tr("Remember that encrypting your wallet cannot fully protect "
-                "your bitcoins from being stolen by malware infecting your computer.");
+                "your dogecoins from being stolen by malware infecting your computer.");
                 if (m_passphrase_out) {
                     m_passphrase_out->assign(newpass1);
                     QMessageBox::warning(this, tr("Wallet to be encrypted"),
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 948df923c07..c807fdfe210 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -324,9 +324,9 @@ void BitcoinGUI::createActions()
     verifyMessageAction = new QAction(tr("&Verify message..."), this);
     verifyMessageAction->setStatusTip(tr("Verify messages to ensure they were signed with specified Dogecoin addresses"));
     m_load_psbt_action = new QAction(tr("&Load PSBT from file..."), this);
-    m_load_psbt_action->setStatusTip(tr("Load Partially Signed Dogecoin Transaction"));
+    m_load_psbt_action->setStatusTip(tr("Load Partially Signed Bitcoin Transaction"));
     m_load_psbt_clipboard_action = new QAction(tr("Load PSBT from clipboard..."), this);
-    m_load_psbt_clipboard_action->setStatusTip(tr("Load Partially Signed Dogecoin Transaction from clipboard"));
+    m_load_psbt_clipboard_action->setStatusTip(tr("Load Partially Signed Bitcoin Transaction from clipboard"));
 
     openRPCConsoleAction = new QAction(tr("Node window"), this);
     openRPCConsoleAction->setStatusTip(tr("Open node debugging and diagnostic console"));
diff --git a/src/qt/bitcoinstrings.cpp b/src/qt/bitcoinstrings.cpp
index 658e49aa778..9f9e884d0b1 100644
--- a/src/qt/bitcoinstrings.cpp
+++ b/src/qt/bitcoinstrings.cpp
@@ -11,12 +11,15 @@
 static const char UNUSED *bitcoin_strings[] = {
 QT_TRANSLATE_NOOP("bitcoin-core", "The %s developers"),
 QT_TRANSLATE_NOOP("bitcoin-core", ""
-"%s corrupt. Try using the wallet tool dogecoin-wallet to salvage or restoring "
-"a backup."),
+"%s corrupt. Try using the wallet tool dogecoin-wallet to salvage or "
+"restoring a backup."),
 QT_TRANSLATE_NOOP("bitcoin-core", ""
 "-maxtxfee is set very high! Fees this large could be paid on a single "
 "transaction."),
 QT_TRANSLATE_NOOP("bitcoin-core", ""
+"-signetchallenge must be specified when using -signet on Dogecoin as no "
+"default Signet is available."),
+QT_TRANSLATE_NOOP("bitcoin-core", ""
 "Cannot obtain a lock on data directory %s. %s is probably already running."),
 QT_TRANSLATE_NOOP("bitcoin-core", ""
 "Cannot provide specific connections and have addrman find outgoing "
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
index 7c72858501c..2f19d4ca48e 100644
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -560,7 +560,7 @@ void CoinControlDialog::updateLabels(CCoinControl& m_coin_control, WalletModel *
     // how many satoshis the estimated fee can vary per byte we guess wrong
     double dFeeVary = (nBytes != 0) ? (double)nPayFee / nBytes : 0;
 
-    QString toolTip4 = tr("Can vary +/- %1 satoshi(s) per input.").arg(dFeeVary);
+    QString toolTip4 = tr("Can vary +/- %1 koinu per input.").arg(dFeeVary);
 
     l3->setToolTip(toolTip4);
     l4->setToolTip(toolTip4);
diff --git a/src/qt/editaddressdialog.cpp b/src/qt/editaddressdialog.cpp
index e0af9a20a8c..766af4414ae 100644
--- a/src/qt/editaddressdialog.cpp
+++ b/src/qt/editaddressdialog.cpp
@@ -110,7 +110,7 @@ void EditAddressDialog::accept()
             break;
         case AddressTableModel::INVALID_ADDRESS:
             QMessageBox::warning(this, windowTitle(),
-                tr("The entered address \"%1\" is not a valid Bitcoin address.").arg(ui->addressEdit->text()),
+                tr("The entered address \"%1\" is not a valid Dogecoin address.").arg(ui->addressEdit->text()),
                 QMessageBox::Ok, QMessageBox::Ok);
             break;
         case AddressTableModel::DUPLICATE_ADDRESS:
diff --git a/src/qt/forms/modaloverlay.ui b/src/qt/forms/modaloverlay.ui
index d2e7ca8f062..01a16216fcd 100644
--- a/src/qt/forms/modaloverlay.ui
+++ b/src/qt/forms/modaloverlay.ui
@@ -130,7 +130,7 @@ QLabel { color: rgb(40,40,40);  }</string>
              <item>
               <widget class="QLabel" name="infoText">
                <property name="text">
-                <string>Recent transactions may not yet be visible, and therefore your wallet's balance might be incorrect. This information will be correct once your wallet has finished synchronizing with the bitcoin network, as detailed below.</string>
+                <string>Recent transactions may not yet be visible, and therefore your wallet's balance might be incorrect. This information will be correct once your wallet has finished synchronizing with the dogecoin network, as detailed below.</string>
                </property>
                <property name="textFormat">
                 <enum>Qt::RichText</enum>
@@ -149,7 +149,7 @@ QLabel { color: rgb(40,40,40);  }</string>
                 </font>
                </property>
                <property name="text">
-                <string>Attempting to spend bitcoins that are affected by not-yet-displayed transactions will not be accepted by the network.</string>
+                <string>Attempting to spend dogecoins that are affected by not-yet-displayed transactions will not be accepted by the network.</string>
                </property>
                <property name="textFormat">
                 <enum>Qt::RichText</enum>
diff --git a/src/qt/forms/openuridialog.ui b/src/qt/forms/openuridialog.ui
index 1b7291ab9da..7d661f738d1 100644
--- a/src/qt/forms/openuridialog.ui
+++ b/src/qt/forms/openuridialog.ui
@@ -11,7 +11,7 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Open bitcoin URI</string>
+   <string>Open dogecoin URI</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
diff --git a/src/qt/forms/optionsdialog.ui b/src/qt/forms/optionsdialog.ui
index 0016fb9739b..ba37dbc4016 100644
--- a/src/qt/forms/optionsdialog.ui
+++ b/src/qt/forms/optionsdialog.ui
@@ -252,7 +252,7 @@
        <item>
         <widget class="QCheckBox" name="mapPortUpnp">
          <property name="toolTip">
-          <string>Automatically open the Bitcoin client port on the router. This only works when your router supports UPnP and it is enabled.</string>
+          <string>Automatically open the Dogecoin client port on the router. This only works when your router supports UPnP and it is enabled.</string>
          </property>
          <property name="text">
           <string>Map port using &amp;UPnP</string>
@@ -272,7 +272,7 @@
        <item>
         <widget class="QCheckBox" name="connectSocks">
          <property name="toolTip">
-          <string>Connect to the Bitcoin network through a SOCKS5 proxy.</string>
+          <string>Connect to the Dogecoin network through a SOCKS5 proxy.</string>
          </property>
          <property name="text">
           <string>&amp;Connect through SOCKS5 proxy (default proxy):</string>
@@ -459,7 +459,7 @@
        <item>
         <widget class="QCheckBox" name="connectSocksTor">
          <property name="toolTip">
-          <string>Connect to the Bitcoin network through a separate SOCKS5 proxy for Tor onion services.</string>
+          <string>Connect to the Dogecoin network through a separate SOCKS5 proxy for Tor onion services.</string>
          </property>
          <property name="text">
           <string>Use separate SOCKS&amp;5 proxy to reach peers via Tor onion services:</string>
diff --git a/src/qt/forms/overviewpage.ui b/src/qt/forms/overviewpage.ui
index ee9d4a113ca..9be86dd0727 100644
--- a/src/qt/forms/overviewpage.ui
+++ b/src/qt/forms/overviewpage.ui
@@ -73,7 +73,7 @@
                </size>
               </property>
               <property name="toolTip">
-               <string>The displayed information may be out of date. Your wallet automatically synchronizes with the Bitcoin network after a connection is established, but this process has not completed yet.</string>
+               <string>The displayed information may be out of date. Your wallet automatically synchronizes with the Dogecoin network after a connection is established, but this process has not completed yet.</string>
               </property>
               <property name="text">
                <string/>
@@ -467,7 +467,7 @@
                </size>
               </property>
               <property name="toolTip">
-               <string>The displayed information may be out of date. Your wallet automatically synchronizes with the Bitcoin network after a connection is established, but this process has not completed yet.</string>
+               <string>The displayed information may be out of date. Your wallet automatically synchronizes with the Dogecoin network after a connection is established, but this process has not completed yet.</string>
               </property>
               <property name="text">
                <string/>
diff --git a/src/qt/forms/receivecoinsdialog.ui b/src/qt/forms/receivecoinsdialog.ui
index 06d39426c9f..01257e0b392 100644
--- a/src/qt/forms/receivecoinsdialog.ui
+++ b/src/qt/forms/receivecoinsdialog.ui
@@ -47,7 +47,7 @@
         <item row="6" column="0">
          <widget class="QLabel" name="label_3">
           <property name="toolTip">
-           <string>An optional message to attach to the payment request, which will be displayed when the request is opened. Note: The message will not be sent with the payment over the Bitcoin network.</string>
+           <string>An optional message to attach to the payment request, which will be displayed when the request is opened. Note: The message will not be sent with the payment over the Dogecoin network.</string>
           </property>
           <property name="text">
            <string>&amp;Message:</string>
diff --git a/src/qt/forms/sendcoinsdialog.ui b/src/qt/forms/sendcoinsdialog.ui
index cfd4bf33d46..c33f4596c75 100644
--- a/src/qt/forms/sendcoinsdialog.ui
+++ b/src/qt/forms/sendcoinsdialog.ui
@@ -850,7 +850,7 @@
                    <property name="toolTip">
                     <string>Specify a custom fee per kB (1,000 bytes) of the transaction's virtual size.
 
-Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis per kB" for a transaction size of 500 bytes (half of 1 kB) would ultimately yield a fee of only 50 satoshis.</string>
+Note:  Since the fee is calculated on a per-byte basis, a fee of "100 koinu per kB" for a transaction size of 500 bytes (half of 1 kB) would ultimately yield a fee of only 50 koinu.</string>
                    </property>
                    <property name="text">
                     <string>per kilobyte</string>
@@ -883,7 +883,7 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
                     <bool>true</bool>
                    </property>
                    <property name="toolTip">
-                    <string>When there is less transaction volume than space in the blocks, miners as well as relaying nodes may enforce a minimum fee. Paying only this minimum fee is just fine, but be aware that this can result in a never confirming transaction once there is more demand for bitcoin transactions than the network can process.</string>
+                    <string>When there is less transaction volume than space in the blocks, miners as well as relaying nodes may enforce a minimum fee. Paying only this minimum fee is just fine, but be aware that this can result in a never confirming transaction once there is more demand for dogecoin transactions than the network can process.</string>
                    </property>
                    <property name="text">
                     <string>A too low fee might result in a never confirming transaction (read the tooltip)</string>
diff --git a/src/qt/forms/sendcoinsentry.ui b/src/qt/forms/sendcoinsentry.ui
index 934363af1f1..e39332d09c0 100644
--- a/src/qt/forms/sendcoinsentry.ui
+++ b/src/qt/forms/sendcoinsentry.ui
@@ -54,7 +54,7 @@
       <item>
        <widget class="QValidatedLineEdit" name="payTo">
         <property name="toolTip">
-         <string>The Bitcoin address to send the payment to</string>
+         <string>The Dogecoin address to send the payment to</string>
         </property>
        </widget>
       </item>
@@ -174,7 +174,7 @@
       <item>
        <widget class="QCheckBox" name="checkboxSubtractFeeFromAmount">
         <property name="toolTip">
-         <string>The fee will be deducted from the amount being sent. The recipient will receive less bitcoins than you enter in the amount field. If multiple recipients are selected, the fee is split equally.</string>
+         <string>The fee will be deducted from the amount being sent. The recipient will receive less dogecoins than you enter in the amount field. If multiple recipients are selected, the fee is split equally.</string>
         </property>
         <property name="text">
          <string>S&amp;ubtract fee from amount</string>
@@ -203,7 +203,7 @@
     <item row="3" column="1">
      <widget class="QLabel" name="messageTextLabel">
       <property name="toolTip">
-       <string>A message that was attached to the bitcoin: URI which will be stored with the transaction for your reference. Note: This message will not be sent over the Bitcoin network.</string>
+       <string>A message that was attached to the dogecoin: URI which will be stored with the transaction for your reference. Note: This message will not be sent over the Dogecoin network.</string>
       </property>
       <property name="textFormat">
        <enum>Qt::PlainText</enum>
diff --git a/src/qt/forms/signverifymessagedialog.ui b/src/qt/forms/signverifymessagedialog.ui
index f42d19093b8..4fbce0a0ab9 100644
--- a/src/qt/forms/signverifymessagedialog.ui
+++ b/src/qt/forms/signverifymessagedialog.ui
@@ -30,7 +30,7 @@
        <item>
         <widget class="QLabel" name="infoLabel_SM">
          <property name="text">
-          <string>You can sign messages/agreements with your addresses to prove you can receive bitcoins sent to them. Be careful not to sign anything vague or random, as phishing attacks may try to trick you into signing your identity over to them. Only sign fully-detailed statements you agree to.</string>
+          <string>You can sign messages/agreements with your addresses to prove you can receive dogecoins sent to them. Be careful not to sign anything vague or random, as phishing attacks may try to trick you into signing your identity over to them. Only sign fully-detailed statements you agree to.</string>
          </property>
          <property name="textFormat">
           <enum>Qt::PlainText</enum>
@@ -48,7 +48,7 @@
          <item>
           <widget class="QValidatedLineEdit" name="addressIn_SM">
            <property name="toolTip">
-            <string>The Bitcoin address to sign the message with</string>
+            <string>The Dogecoin address to sign the message with</string>
            </property>
           </widget>
          </item>
@@ -158,7 +158,7 @@
          <item>
           <widget class="QPushButton" name="signMessageButton_SM">
            <property name="toolTip">
-            <string>Sign the message to prove you own this Bitcoin address</string>
+            <string>Sign the message to prove you own this Dogecoin address</string>
            </property>
            <property name="text">
             <string>Sign &amp;Message</string>
@@ -264,7 +264,7 @@
          <item>
           <widget class="QValidatedLineEdit" name="addressIn_VM">
            <property name="toolTip">
-            <string>The Bitcoin address the message was signed with</string>
+            <string>The Dogecoin address the message was signed with</string>
            </property>
           </widget>
          </item>
@@ -315,7 +315,7 @@
          <item>
           <widget class="QPushButton" name="verifyMessageButton_VM">
            <property name="toolTip">
-            <string>Verify the message to ensure it was signed with the specified Bitcoin address</string>
+            <string>Verify the message to ensure it was signed with the specified Dogecoin address</string>
            </property>
            <property name="text">
             <string>Verify &amp;Message</string>
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index cab015bdbe4..9eb3667de15 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -105,7 +105,7 @@ void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent)
     widget->setFont(fixedPitchFont());
     // We don't want translators to use own addresses in translations
     // and this is the only place, where this address is supplied.
-    widget->setPlaceholderText(QObject::tr("Enter a Bitcoin address (e.g. %1)").arg(
+    widget->setPlaceholderText(QObject::tr("Enter a Dogecoin address (e.g. %1)").arg(
         QString::fromStdString(DummyAddress(Params()))));
     widget->setValidator(new BitcoinAddressEntryValidator(parent));
     widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
index 235722d091a..309c71a75fa 100644
--- a/src/qt/intro.cpp
+++ b/src/qt/intro.cpp
@@ -134,8 +134,8 @@ Intro::Intro(QWidget *parent, int64_t blockchain_size_gb, int64_t chain_state_si
     ui->lblExplanation1->setText(ui->lblExplanation1->text()
         .arg(PACKAGE_NAME)
         .arg(m_blockchain_size_gb)
-        .arg(2009)
-        .arg(tr("Bitcoin"))
+        .arg(2013)
+        .arg(tr("Dogecoin"))
     );
     ui->lblExplanation2->setText(ui->lblExplanation2->text().arg(PACKAGE_NAME));
 
@@ -362,7 +362,7 @@ void Intro::UpdatePruneLabels(bool prune_checked)
     }
     ui->lblExplanation3->setVisible(prune_checked);
     ui->sizeWarningLabel->setText(
-        tr("%1 will download and store a copy of the Bitcoin block chain.").arg(PACKAGE_NAME) + " " +
+        tr("%1 will download and store a copy of the Dogecoin block chain.").arg(PACKAGE_NAME) + " " +
         storageRequiresMsg.arg(m_required_space_gb) + " " +
         tr("The wallet will also be stored in this directory.")
     );
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
index 066857568d6..38633162fe0 100644
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -38,7 +38,7 @@
 #include <QUrlQuery>
 
 const int BITCOIN_IPC_CONNECT_TIMEOUT = 1000; // milliseconds
-const QString BITCOIN_IPC_PREFIX("bitcoin:");
+const QString BITCOIN_IPC_PREFIX("dogecoin:");
 
 //
 // Create a name that is unique for:
@@ -172,7 +172,7 @@ PaymentServer::PaymentServer(QObject* parent, bool startLocalServer) :
         if (!uriServer->listen(name)) {
             // constructor is called early in init, so don't use "Q_EMIT message()" here
             QMessageBox::critical(nullptr, tr("Payment request error"),
-                tr("Cannot start bitcoin: click-to-pay handler"));
+                tr("Cannot start dogecoin: click-to-pay handler"));
         }
         else {
             connect(uriServer, &QLocalServer::newConnection, this, &PaymentServer::handleURIConnection);
@@ -220,9 +220,9 @@ void PaymentServer::handleURIOrFile(const QString& s)
         return;
     }
 
-    if (s.startsWith("bitcoin://", Qt::CaseInsensitive))
+    if (s.startsWith("dogecoin://", Qt::CaseInsensitive))
     {
-        Q_EMIT message(tr("URI handling"), tr("'bitcoin://' is not a valid URI. Use 'bitcoin:' instead."),
+        Q_EMIT message(tr("URI handling"), tr("'dogecoin://' is not a valid URI. Use 'dogecoin:' instead."),
             CClientUIInterface::MSG_ERROR);
     }
     else if (s.startsWith(BITCOIN_IPC_PREFIX, Qt::CaseInsensitive)) // bitcoin: URI
@@ -249,7 +249,7 @@ void PaymentServer::handleURIOrFile(const QString& s)
             }
             else
                 Q_EMIT message(tr("URI handling"),
-                    tr("URI cannot be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters."),
+                    tr("URI cannot be parsed! This can be caused by an invalid Dogecoin address or malformed URI parameters."),
                     CClientUIInterface::ICON_WARNING);
 
             return;
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 62606ff0b00..1ed9c4c7d67 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -876,7 +876,7 @@ void SendCoinsDialog::coinControlChangeEdited(const QString& text)
         }
         else if (!IsValidDestination(dest)) // Invalid address
         {
-            ui->labelCoinControlChangeLabel->setText(tr("Warning: Invalid Bitcoin address"));
+            ui->labelCoinControlChangeLabel->setText(tr("Warning: Invalid Dogecoin address"));
         }
         else // Valid address
         {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 72e7e09749a..67d765de188 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1148,8 +1148,8 @@ static RPCHelpMan gettxout()
                                 {RPCResult::Type::STR_HEX, "hex", ""},
                                 {RPCResult::Type::NUM, "reqSigs", "Number of required signatures"},
                                 {RPCResult::Type::STR_HEX, "type", "The type, eg pubkeyhash"},
-                                {RPCResult::Type::ARR, "addresses", "array of bitcoin addresses",
-                                    {{RPCResult::Type::STR, "address", "bitcoin address"}}},
+                                {RPCResult::Type::ARR, "addresses", "array of dogecoin addresses",
+                                    {{RPCResult::Type::STR, "address", "dogecoin address"}}},
                             }},
                         {RPCResult::Type::BOOL, "coinbase", "Coinbase or not"},
                     }},
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 4d45c9f68e2..75216a2e94d 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -213,7 +213,7 @@ static RPCHelpMan generatetodescriptor()
         "\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n",
         {
             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
-            {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated bitcoin to."},
+            {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated dogecoin to."},
             {"maxtries", RPCArg::Type::NUM, /* default */ ToString(DEFAULT_MAX_TRIES), "How many iterations to try."},
         },
         RPCResult{
@@ -261,7 +261,7 @@ static RPCHelpMan generatetoaddress()
                 "\nMine blocks immediately to a specified address (before the RPC call returns)\n",
                 {
                     {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated dogecoin to."},
                     {"maxtries", RPCArg::Type::NUM, /* default */ ToString(DEFAULT_MAX_TRIES), "How many iterations to try."},
                 },
                 RPCResult{
@@ -272,7 +272,7 @@ static RPCHelpMan generatetoaddress()
                 RPCExamples{
             "\nGenerate 11 blocks to myaddress\n"
             + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
-            + "If you are using the " PACKAGE_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
+            + "If you are using the " PACKAGE_NAME " wallet, you can get a new address to send the newly generated dogecoin to with:\n"
             + HelpExampleCli("getnewaddress", "")
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
@@ -300,7 +300,7 @@ static RPCHelpMan generateblock()
     return RPCHelpMan{"generateblock",
         "\nMine a block with a set of ordered transactions immediately to a specified address or descriptor (before the RPC call returns)\n",
         {
-            {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated bitcoin to."},
+            {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated dogecoin to."},
             {"transactions", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings which are either txids or raw transactions.\n"
                 "Txids must reference transactions currently in the mempool.\n"
                 "All transactions must be valid and in valid order, otherwise the block will be rejected.",
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index cca4c6787f0..53130a5f4a9 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -32,15 +32,15 @@
 static RPCHelpMan validateaddress()
 {
     return RPCHelpMan{"validateaddress",
-                "\nReturn information about the given bitcoin address.\n",
+                "\nReturn information about the given dogecoin address.\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to validate"},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address to validate"},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
                     {
                         {RPCResult::Type::BOOL, "isvalid", "If the address is valid or not. If not, this is the only property returned."},
-                        {RPCResult::Type::STR, "address", "The bitcoin address validated"},
+                        {RPCResult::Type::STR, "address", "The dogecoin address validated"},
                         {RPCResult::Type::STR_HEX, "scriptPubKey", "The hex-encoded scriptPubKey generated by the address"},
                         {RPCResult::Type::BOOL, "isscript", "If the key is a script"},
                         {RPCResult::Type::BOOL, "iswitness", "If the address is a witness address"},
@@ -273,7 +273,7 @@ static RPCHelpMan verifymessage()
     return RPCHelpMan{"verifymessage",
                 "\nVerify a signed message\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to use for the signature."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address to use for the signature."},
                     {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature provided by the signer in base 64 encoding (see signmessage)."},
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message that was signed."},
                 },
@@ -284,11 +284,11 @@ static RPCHelpMan verifymessage()
             "\nUnlock the wallet for 30 seconds\n"
             + HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
             "\nCreate the signature\n"
-            + HelpExampleCli("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
+            + HelpExampleCli("signmessage", "\"DH9fPpKHLiP5eaAD3pXxxUZmPktGNGTFp6\" \"my message\"") +
             "\nVerify the signature\n"
-            + HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"signature\" \"my message\"") +
+            + HelpExampleCli("verifymessage", "\"DH9fPpKHLiP5eaAD3pXxxUZmPktGNGTFp6\" \"signature\" \"my message\"") +
             "\nAs a JSON-RPC call\n"
-            + HelpExampleRpc("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"signature\", \"my message\"")
+            + HelpExampleRpc("verifymessage", "\"DH9fPpKHLiP5eaAD3pXxxUZmPktGNGTFp6\", \"signature\", \"my message\"")
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
@@ -332,7 +332,7 @@ static RPCHelpMan signmessagewithprivkey()
             "\nCreate the signature\n"
             + HelpExampleCli("signmessagewithprivkey", "\"privkey\" \"my message\"") +
             "\nVerify the signature\n"
-            + HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"signature\" \"my message\"") +
+            + HelpExampleCli("verifymessage", "\"DH9fPpKHLiP5eaAD3pXxxUZmPktGNGTFp6\" \"signature\" \"my message\"") +
             "\nAs a JSON-RPC call\n"
             + HelpExampleRpc("signmessagewithprivkey", "\"privkey\", \"my message\"")
                 },
@@ -611,7 +611,7 @@ static RPCHelpMan echo(const std::string& name)
                 "\nSimply echo back the input arguments. This command is for testing.\n"
                 "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n"
                 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
-                "bitcoin-cli and the GUI. There is no server-side difference.",
+                "dogecoin-cli and the GUI. There is no server-side difference.",
                 {
                     {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, ""},
                     {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, ""},
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 49d480c5f51..2d1364eed77 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -286,8 +286,8 @@ static RPCHelpMan addnode()
                 },
                 RPCResult{RPCResult::Type::NONE, "", ""},
                 RPCExamples{
-                    HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"")
-            + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")
+                    HelpExampleCli("addnode", "\"192.168.0.6:22556\" \"onetry\"")
+            + HelpExampleRpc("addnode", "\"192.168.0.6:22556\", \"onetry\"")
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
@@ -340,9 +340,9 @@ static RPCHelpMan disconnectnode()
                 },
                 RPCResult{RPCResult::Type::NONE, "", ""},
                 RPCExamples{
-                    HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"")
+                    HelpExampleCli("disconnectnode", "\"192.168.0.6:22556\"")
             + HelpExampleCli("disconnectnode", "\"\" 1")
-            + HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"")
+            + HelpExampleRpc("disconnectnode", "\"192.168.0.6:22556\"")
             + HelpExampleRpc("disconnectnode", "\"\", 1")
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
@@ -394,7 +394,7 @@ static RPCHelpMan getaddednodeinfo()
                             {
                                 {RPCResult::Type::OBJ, "", "",
                                 {
-                                    {RPCResult::Type::STR, "address", "The bitcoin server IP and port we're connected to"},
+                                    {RPCResult::Type::STR, "address", "The dogecoin server IP and port we're connected to"},
                                     {RPCResult::Type::STR, "connected", "connection, inbound or outbound"},
                                 }},
                             }},
@@ -858,8 +858,8 @@ static RPCHelpMan addpeeraddress()
             },
         },
         RPCExamples{
-            HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333")
-    + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333")
+            HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 22556")
+    + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 22556")
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 46222c47f6d..52e38c3aa84 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -137,7 +137,7 @@ static RPCHelpMan getrawtransaction()
                                          {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
                                          {RPCResult::Type::ARR, "addresses", "",
                                          {
-                                             {RPCResult::Type::STR, "address", "bitcoin address"},
+                                             {RPCResult::Type::STR, "address", "dogecoin address"},
                                          }},
                                      }},
                                  }},
@@ -396,7 +396,7 @@ static RPCHelpMan createrawtransaction()
                         {
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                                 {
-                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT},
+                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the dogecoin address, the value (float or string) is the amount in " + CURRENCY_UNIT},
                                 },
                                 },
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
@@ -496,7 +496,7 @@ static RPCHelpMan decoderawtransaction()
                                     {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
                                     {RPCResult::Type::ARR, "addresses", "",
                                     {
-                                        {RPCResult::Type::STR, "address", "bitcoin address"},
+                                        {RPCResult::Type::STR, "address", "dogecoin address"},
                                     }},
                                 }},
                             }},
@@ -553,7 +553,7 @@ static RPCHelpMan decodescript()
                         {RPCResult::Type::NUM, "reqSigs", "The required signatures"},
                         {RPCResult::Type::ARR, "addresses", "",
                         {
-                            {RPCResult::Type::STR, "address", "bitcoin address"},
+                            {RPCResult::Type::STR, "address", "dogecoin address"},
                         }},
                         {RPCResult::Type::STR, "p2sh", "address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH)"},
                         {RPCResult::Type::OBJ, "segwit", "Result of a witness script public key wrapping this redeem script (not returned if the script is a P2SH or witness)",
@@ -1023,7 +1023,7 @@ static RPCHelpMan decodepsbt()
                                         {RPCResult::Type::STR, "asm", "The asm"},
                                         {RPCResult::Type::STR_HEX, "hex", "The hex"},
                                         {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
-                                        {RPCResult::Type::STR, "address"," Bitcoin address if there is one"},
+                                        {RPCResult::Type::STR, "address"," Dogecoin address if there is one"},
                                     }},
                                 }},
                                 {RPCResult::Type::OBJ_DYN, "partial_signatures", /* optional */ true, "",
@@ -1433,7 +1433,7 @@ static RPCHelpMan createpsbt()
                         {
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                                 {
-                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT},
+                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the dogecoin address, the value (float or string) is the amount in " + CURRENCY_UNIT},
                                 },
                                 },
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 1b21587b6dc..b8df0f98f71 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -18,7 +18,7 @@
 #include <boost/algorithm/string/split.hpp>
 
 const std::string UNIX_EPOCH_TIME = "UNIX epoch time";
-const std::string EXAMPLE_ADDRESS[2] = {"bc1q09vm5lfy0j5reeulh4x5752q25uqqvz34hufdl", "bc1q02ad21edsxd23d32dfgqqsz4vv4nmtfzuklhy3"};
+const std::string EXAMPLE_ADDRESS[2] = {"DRF7yvmFHR5gMXRtijkbkPzmLYnMfTYMGZ", "DH9fPpKHLiP5eaAD3pXxxUZmPktGNGTFp6"};
 
 void RPCTypeCheck(const UniValue& params,
                   const std::list<UniValueType>& typesExpected,
@@ -132,7 +132,7 @@ CoinStatsHashType ParseHashType(const UniValue& param, const CoinStatsHashType d
 
 std::string HelpExampleCli(const std::string& methodname, const std::string& args)
 {
-    return "> bitcoin-cli " + methodname + " " + args + "\n";
+    return "> dogecoin-cli " + methodname + " " + args + "\n";
 }
 
 std::string HelpExampleRpc(const std::string& methodname, const std::string& args)
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 45b0bb0c7eb..3d704e70c5a 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -30,8 +30,8 @@
 extern const std::string UNIX_EPOCH_TIME;
 
 /**
- * Example bech32 addresses for the RPCExamples help documentation. They are intentionally
- * invalid to prevent accidental transactions by users.
+ * Example pubkeyhash addresses for the RPCExamples help documentation.
+ * Dogecoin: Use pubkeyhash rather than BECH32 addresses.
  */
 extern const std::string EXAMPLE_ADDRESS[2];
 
diff --git a/src/util/threadnames.cpp b/src/util/threadnames.cpp
index 764fffabd71..7887671075d 100644
--- a/src/util/threadnames.cpp
+++ b/src/util/threadnames.cpp
@@ -56,7 +56,7 @@ static void SetInternalName(std::string name) { }
 
 void util::ThreadRename(std::string&& name)
 {
-    SetThreadName(("b-" + name).c_str());
+    SetThreadName(("d-" + name).c_str());
     SetInternalName(std::move(name));
 }
 
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 85aae0170d8..8c0c80e57ed 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -135,7 +135,7 @@ bool BerkeleyEnvironment::Open(bilingual_str& err)
     fs::path pathIn = strPath;
     TryCreateDirectories(pathIn);
     if (!LockDirectory(pathIn, ".walletlock")) {
-        LogPrintf("Cannot obtain a lock on wallet directory %s. Another instance of bitcoin may be using it.\n", strPath);
+        LogPrintf("Cannot obtain a lock on wallet directory %s. Another instance of dogecoin may be using it.\n", strPath);
         err = strprintf(_("Error initializing wallet database environment %s!"), Directory());
         return false;
     }
@@ -277,7 +277,7 @@ bool BerkeleyDatabase::Verify(bilingual_str& errorStr)
         Db db(env->dbenv.get(), 0);
         int result = db.verify(strFile.c_str(), nullptr, nullptr, 0);
         if (result != 0) {
-            errorStr = strprintf(_("%s corrupt. Try using the wallet tool bitcoin-wallet to salvage or restoring a backup."), file_path);
+            errorStr = strprintf(_("%s corrupt. Try using the wallet tool dogecoin-wallet to salvage or restoring a backup."), file_path);
             return false;
         }
     }
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 6b46868d10f..6f4864ceee8 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -233,7 +233,7 @@ RPCHelpMan importaddress()
             "as change, and not show up in many RPCs.\n"
             "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Bitcoin address (or hex-encoded script)"},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Dogecoin address (or hex-encoded script)"},
                     {"label", RPCArg::Type::STR, /* default */ "\"\"", "An optional label"},
                     {"rescan", RPCArg::Type::BOOL, /* default */ "true", "Rescan the wallet for transactions"},
                     {"p2sh", RPCArg::Type::BOOL, /* default */ "false", "Add the P2SH version of the script as well"},
@@ -306,7 +306,7 @@ RPCHelpMan importaddress()
 
             pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
         } else {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address or script");
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Dogecoin address or script");
         }
     }
     if (fRescan)
@@ -672,7 +672,7 @@ RPCHelpMan dumpprivkey()
                 "\nReveals the private key corresponding to 'address'.\n"
                 "Then the importprivkey can be used with this output\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for the private key"},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address for the private key"},
                 },
                 RPCResult{
                     RPCResult::Type::STR, "key", "The private key"
@@ -697,7 +697,7 @@ RPCHelpMan dumpprivkey()
     std::string strAddress = request.params[0].get_str();
     CTxDestination dest = DecodeDestination(strAddress);
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Dogecoin address");
     }
     auto keyid = GetKeyForDestination(spk_man, dest);
     if (keyid.IsNull()) {
@@ -781,7 +781,7 @@ RPCHelpMan dumpwallet()
     std::sort(vKeyBirth.begin(), vKeyBirth.end());
 
     // produce output
-    file << strprintf("# Wallet dump created by Bitcoin %s\n", CLIENT_BUILD);
+    file << strprintf("# Wallet dump created by Dogecoin %s\n", CLIENT_BUILD);
     file << strprintf("# * Created on %s\n", FormatISO8601DateTime(GetTime()));
     file << strprintf("# * Best block at time of backup was %i (%s),\n", wallet.GetLastBlockHeight(), wallet.GetLastBlockHash().ToString());
     int64_t block_time = 0;
@@ -1431,7 +1431,7 @@ RPCHelpMan importmulti()
                                       "block from time %d, which is after or within %d seconds of key creation, and "
                                       "could contain transactions pertaining to the key. As a result, transactions "
                                       "and coins using this key may not appear in the wallet. This error could be "
-                                      "caused by pruning or data corruption (see bitcoind log for details) and could "
+                                      "caused by pruning or data corruption (see dogecoind log for details) and could "
                                       "be dealt with by downloading and rescanning the relevant blocks (see -reindex "
                                       "and -rescan options).",
                                 GetImportTimestamp(request, now), scannedTime - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
@@ -1726,7 +1726,7 @@ RPCHelpMan importdescriptors()
                                       "block from time %d, which is after or within %d seconds of key creation, and "
                                       "could contain transactions pertaining to the desc. As a result, transactions "
                                       "and coins using this desc may not appear in the wallet. This error could be "
-                                      "caused by pruning or data corruption (see bitcoind log for details) and could "
+                                      "caused by pruning or data corruption (see dogecoind log for details) and could "
                                       "be dealt with by downloading and rescanning the relevant blocks (see -reindex "
                                       "and -rescan options).",
                                 GetImportTimestamp(request, now), scanned_time - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index e6373715738..d55ad7824bb 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -237,7 +237,7 @@ static void SetFeeEstimateMode(const CWallet& wallet, CCoinControl& cc, const Un
 static RPCHelpMan getnewaddress()
 {
     return RPCHelpMan{"getnewaddress",
-                "\nReturns a new Bitcoin address for receiving payments.\n"
+                "\nReturns a new Dogecoin address for receiving payments.\n"
                 "If 'label' is specified, it is added to the address book \n"
                 "so payments received with the address will be associated with 'label'.\n",
                 {
@@ -245,7 +245,7 @@ static RPCHelpMan getnewaddress()
                     {"address_type", RPCArg::Type::STR, /* default */ "set by -addresstype", "The address type to use. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
                 },
                 RPCResult{
-                    RPCResult::Type::STR, "address", "The new bitcoin address"
+                    RPCResult::Type::STR, "address", "The new dogecoin address"
                 },
                 RPCExamples{
                     HelpExampleCli("getnewaddress", "")
@@ -289,7 +289,7 @@ static RPCHelpMan getnewaddress()
 static RPCHelpMan getrawchangeaddress()
 {
     return RPCHelpMan{"getrawchangeaddress",
-                "\nReturns a new Bitcoin address, for receiving change.\n"
+                "\nReturns a new Dogecoin address, for receiving change.\n"
                 "This is for use with raw transactions, NOT normal use.\n",
                 {
                     {"address_type", RPCArg::Type::STR, /* default */ "set by -changetype", "The address type to use. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
@@ -336,7 +336,7 @@ static RPCHelpMan setlabel()
     return RPCHelpMan{"setlabel",
                 "\nSets the label associated with the given address.\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to be associated with a label."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address to be associated with a label."},
                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label to assign to the address."},
                 },
                 RPCResult{RPCResult::Type::NONE, "", ""},
@@ -354,7 +354,7 @@ static RPCHelpMan setlabel()
 
     CTxDestination dest = DecodeDestination(request.params[0].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Dogecoin address");
     }
 
     std::string label = LabelFromValue(request.params[1]);
@@ -376,7 +376,7 @@ void ParseRecipients(const UniValue& address_amounts, const UniValue& subtract_f
     for (const std::string& address: address_amounts.getKeys()) {
         CTxDestination dest = DecodeDestination(address);
         if (!IsValidDestination(dest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + address);
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dogecoin address: ") + address);
         }
 
         if (destinations.count(dest)) {
@@ -439,7 +439,7 @@ static RPCHelpMan sendtoaddress()
                 "\nSend an amount to a given address." +
         HELP_REQUIRING_PASSPHRASE,
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to send to."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address to send to."},
                     {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},
                     {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "A comment used to store what the transaction is for.\n"
                                          "This is not part of the transaction, just kept in your wallet."},
@@ -447,7 +447,7 @@ static RPCHelpMan sendtoaddress()
                                          "to which you're sending the transaction. This is not part of the \n"
                                          "transaction, just kept in your wallet."},
                     {"subtractfeefromamount", RPCArg::Type::BOOL, /* default */ "false", "The fee will be deducted from the amount being sent.\n"
-                                         "The recipient will receive less bitcoins than you enter in the amount field."},
+                                         "The recipient will receive less dogecoins than you enter in the amount field."},
                     {"replaceable", RPCArg::Type::BOOL, /* default */ "wallet default", "Allow this transaction to be replaced by a transaction with higher fees via BIP 125"},
                     {"conf_target", RPCArg::Type::NUM, /* default */ "wallet -txconfirmtarget", "Confirmation target in blocks"},
                     {"estimate_mode", RPCArg::Type::STR, /* default */ "unset", std::string() + "The fee estimate mode, must be one of (case insensitive):\n"
@@ -550,7 +550,7 @@ static RPCHelpMan listaddressgroupings()
                         {
                             {RPCResult::Type::ARR, "", "",
                             {
-                                {RPCResult::Type::STR, "address", "The bitcoin address"},
+                                {RPCResult::Type::STR, "address", "The dogecoin address"},
                                 {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT},
                                 {RPCResult::Type::STR, "label", /* optional */ true, "The label"},
                             }},
@@ -603,7 +603,7 @@ static RPCHelpMan signmessage()
                 "\nSign a message with the private key of an address" +
         HELP_REQUIRING_PASSPHRASE,
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to use for the private key."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address to use for the private key."},
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},
                 },
                 RPCResult{
@@ -667,7 +667,7 @@ static CAmount GetReceived(const CWallet& wallet, const UniValue& params, bool b
         // Get the address
         CTxDestination dest = DecodeDestination(params[0].get_str());
         if (!IsValidDestination(dest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Dogecoin address");
         }
         CScript script_pub_key = GetScriptForDestination(dest);
         if (!wallet.IsMine(script_pub_key)) {
@@ -706,7 +706,7 @@ static RPCHelpMan getreceivedbyaddress()
     return RPCHelpMan{"getreceivedbyaddress",
                 "\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for transactions."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address for transactions."},
                     {"minconf", RPCArg::Type::NUM, /* default */ "1", "Only include transactions confirmed at least this many times."},
                 },
                 RPCResult{
@@ -869,14 +869,14 @@ static RPCHelpMan sendmany()
                     {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO, "Must be set to \"\" for backwards compatibility.", "\"\""},
                     {"amounts", RPCArg::Type::OBJ, RPCArg::Optional::NO, "The addresses and amounts",
                         {
-                            {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The bitcoin address is the key, the numeric amount (can be string) in " + CURRENCY_UNIT + " is the value"},
+                            {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The dogecoin address is the key, the numeric amount (can be string) in " + CURRENCY_UNIT + " is the value"},
                         },
                     },
                     {"minconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "Ignored dummy value"},
                     {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "A comment"},
                     {"subtractfeefrom", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "The addresses.\n"
                                        "The fee will be equally deducted from the amount of each selected address.\n"
-                                       "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
+                                       "Those recipients will receive less dogecoins than you enter in their corresponding amount field.\n"
                                        "If no addresses are specified here, the sender pays the fee.",
                         {
                             {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Subtract fee from this address"},
@@ -959,15 +959,15 @@ static RPCHelpMan addmultisigaddress()
 {
     return RPCHelpMan{"addmultisigaddress",
                 "\nAdd an nrequired-to-sign multisignature address to the wallet. Requires a new wallet backup.\n"
-                "Each key is a Bitcoin address or hex-encoded public key.\n"
+                "Each key is a Dogecoin address or hex-encoded public key.\n"
                 "This functionality is only intended for use with non-watchonly addresses.\n"
                 "See `importaddress` for watchonly p2sh address support.\n"
                 "If 'label' is specified, assign address to that label.\n",
                 {
                     {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO, "The number of required signatures out of the n keys or addresses."},
-                    {"keys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The bitcoin addresses or hex-encoded public keys",
+                    {"keys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The dogecoin addresses or hex-encoded public keys",
                         {
-                            {"key", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "bitcoin address or hex-encoded public key"},
+                            {"key", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "dogecoin address or hex-encoded public key"},
                         },
                         },
                     {"label", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "A label to assign the addresses to."},
@@ -1424,7 +1424,7 @@ static RPCHelpMan listtransactions()
                         {RPCResult::Type::OBJ, "", "", Cat(Cat<std::vector<RPCResult>>(
                         {
                             {RPCResult::Type::BOOL, "involvesWatchonly", "Only returns true if imported addresses were involved in transaction."},
-                            {RPCResult::Type::STR, "address", "The bitcoin address of the transaction."},
+                            {RPCResult::Type::STR, "address", "The dogecoin address of the transaction."},
                             {RPCResult::Type::STR, "category", "The transaction category.\n"
                                 "\"send\"                  Transactions sent.\n"
                                 "\"receive\"               Non-coinbase transactions received.\n"
@@ -1539,7 +1539,7 @@ static RPCHelpMan listsinceblock()
                             {RPCResult::Type::OBJ, "", "", Cat(Cat<std::vector<RPCResult>>(
                             {
                                 {RPCResult::Type::BOOL, "involvesWatchonly", "Only returns true if imported addresses were involved in transaction."},
-                                {RPCResult::Type::STR, "address", "The bitcoin address of the transaction."},
+                                {RPCResult::Type::STR, "address", "The dogecoin address of the transaction."},
                                 {RPCResult::Type::STR, "category", "The transaction category.\n"
                                     "\"send\"                  Transactions sent.\n"
                                     "\"receive\"               Non-coinbase transactions received.\n"
@@ -1684,7 +1684,7 @@ static RPCHelpMan gettransaction()
                             {RPCResult::Type::OBJ, "", "",
                             {
                                 {RPCResult::Type::BOOL, "involvesWatchonly", "Only returns true if imported addresses were involved in transaction."},
-                                {RPCResult::Type::STR, "address", "The bitcoin address involved in the transaction."},
+                                {RPCResult::Type::STR, "address", "The dogecoin address involved in the transaction."},
                                 {RPCResult::Type::STR, "category", "The transaction category.\n"
                                     "\"send\"                  Transactions sent.\n"
                                     "\"receive\"               Non-coinbase transactions received.\n"
@@ -1899,7 +1899,7 @@ static RPCHelpMan walletpassphrase()
 {
     return RPCHelpMan{"walletpassphrase",
                 "\nStores the wallet decryption key in memory for 'timeout' seconds.\n"
-                "This is needed prior to performing transactions related to private keys such as sending bitcoins\n"
+                "This is needed prior to performing transactions related to private keys such as sending dogecoins\n"
             "\nNote:\n"
             "Issuing the walletpassphrase command while the wallet is already unlocked will set a new unlock\n"
             "time that overrides the old one.\n",
@@ -2094,7 +2094,7 @@ static RPCHelpMan encryptwallet()
                 RPCExamples{
             "\nEncrypt your wallet\n"
             + HelpExampleCli("encryptwallet", "\"my pass phrase\"") +
-            "\nNow set the passphrase to use the wallet, such as for signing or sending bitcoin\n"
+            "\nNow set the passphrase to use the wallet, such as for signing or sending dogecoin\n"
             + HelpExampleCli("walletpassphrase", "\"my pass phrase\"") +
             "\nNow we can do something like sign\n"
             + HelpExampleCli("signmessage", "\"address\" \"test message\"") +
@@ -2144,7 +2144,7 @@ static RPCHelpMan lockunspent()
                 "\nUpdates list of temporarily unspendable outputs.\n"
                 "Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
                 "If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
-                "A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
+                "A locked transaction output will not be chosen by automatic coin selection, when spending dogecoins.\n"
                 "Manually selected coins are automatically unlocked.\n"
                 "Locks are stored in memory only. Nodes start with zero locked outputs, and the locked output list\n"
                 "is always cleared (by virtue of process exit) when a node stops or fails.\n"
@@ -2594,7 +2594,7 @@ static RPCHelpMan loadwallet()
 {
     return RPCHelpMan{"loadwallet",
                 "\nLoads a wallet from a wallet file or directory."
-                "\nNote that all wallet command-line options used when starting bitcoind will be"
+                "\nNote that all wallet command-line options used when starting dogecoind will be"
                 "\napplied to the new wallet (eg -rescan, etc).\n",
                 {
                     {"filename", RPCArg::Type::STR, RPCArg::Optional::NO, "The wallet directory or .dat file."},
@@ -2847,9 +2847,9 @@ static RPCHelpMan listunspent()
                 {
                     {"minconf", RPCArg::Type::NUM, /* default */ "1", "The minimum confirmations to filter"},
                     {"maxconf", RPCArg::Type::NUM, /* default */ "9999999", "The maximum confirmations to filter"},
-                    {"addresses", RPCArg::Type::ARR, /* default */ "empty array", "The bitcoin addresses to filter",
+                    {"addresses", RPCArg::Type::ARR, /* default */ "empty array", "The dogecoin addresses to filter",
                         {
-                            {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "bitcoin address"},
+                            {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "dogecoin address"},
                         },
                     },
                     {"include_unsafe", RPCArg::Type::BOOL, /* default */ "true", "Include outputs that are not safe to spend\n"
@@ -2870,7 +2870,7 @@ static RPCHelpMan listunspent()
                         {
                             {RPCResult::Type::STR_HEX, "txid", "the transaction id"},
                             {RPCResult::Type::NUM, "vout", "the vout value"},
-                            {RPCResult::Type::STR, "address", "the bitcoin address"},
+                            {RPCResult::Type::STR, "address", "the dogecoin address"},
                             {RPCResult::Type::STR, "label", "The associated label, or \"\" for the default label"},
                             {RPCResult::Type::STR, "scriptPubKey", "the script key"},
                             {RPCResult::Type::STR_AMOUNT, "amount", "the transaction output amount in " + CURRENCY_UNIT},
@@ -2920,7 +2920,7 @@ static RPCHelpMan listunspent()
             const UniValue& input = inputs[idx];
             CTxDestination dest = DecodeDestination(input.get_str());
             if (!IsValidDestination(dest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + input.get_str());
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dogecoin address: ") + input.get_str());
             }
             if (!destinations.insert(dest).second) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + input.get_str());
@@ -3113,7 +3113,7 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
             CTxDestination dest = DecodeDestination(change_address_str);
 
             if (!IsValidDestination(dest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Change address must be a valid bitcoin address");
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Change address must be a valid dogecoin address");
             }
 
             coinControl.destChange = dest;
@@ -3211,7 +3211,7 @@ static RPCHelpMan fundrawtransaction()
                     {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, "for backward compatibility: passing in a true instead of an object will result in {\"includeWatching\":true}",
                         {
                             {"add_inputs", RPCArg::Type::BOOL, /* default */ "true", "For a transaction with existing inputs, automatically include more if they are not enough."},
-                            {"changeAddress", RPCArg::Type::STR, /* default */ "pool address", "The bitcoin address to receive the change"},
+                            {"changeAddress", RPCArg::Type::STR, /* default */ "pool address", "The dogecoin address to receive the change"},
                             {"changePosition", RPCArg::Type::NUM, /* default */ "random", "The index of the change output"},
                             {"change_type", RPCArg::Type::STR, /* default */ "set by -changetype", "The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
                             {"includeWatching", RPCArg::Type::BOOL, /* default */ "true for watch-only wallets, otherwise false", "Also select inputs which are watch only.\n"
@@ -3222,7 +3222,7 @@ static RPCHelpMan fundrawtransaction()
                             {"feeRate", RPCArg::Type::AMOUNT, /* default */ "not set, fall back to wallet fee estimation", "Specify a fee rate in " + CURRENCY_UNIT + "/kvB."},
                             {"subtractFeeFromOutputs", RPCArg::Type::ARR, /* default */ "empty array", "The integers.\n"
                                                           "The fee will be equally deducted from the amount of each specified output.\n"
-                                                          "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
+                                                          "Those recipients will receive less dogecoins than you enter in their corresponding amount field.\n"
                                                           "If no outputs are specified here, the sender pays the fee.",
                                 {
                                     {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
@@ -3455,7 +3455,7 @@ static RPCHelpMan bumpfee_helper(std::string method_name)
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !want_psbt) {
         if (!pwallet->chain().rpcEnableDeprecated("bumpfee")) {
-            throw JSONRPCError(RPC_METHOD_DEPRECATED, "Using bumpfee with wallets that have private keys disabled is deprecated. Use psbtbumpfee instead or restart bitcoind with -deprecatedrpc=bumpfee. This functionality will be removed in 0.22");
+            throw JSONRPCError(RPC_METHOD_DEPRECATED, "Using bumpfee with wallets that have private keys disabled is deprecated. Use psbtbumpfee instead or restart dogecoind with -deprecatedrpc=bumpfee. This functionality will be removed in 0.22");
         }
         want_psbt = true;
     }
@@ -3770,15 +3770,15 @@ static UniValue AddressBookDataToJSON(const CAddressBookData& data, const bool v
 RPCHelpMan getaddressinfo()
 {
     return RPCHelpMan{"getaddressinfo",
-                "\nReturn information about the given bitcoin address.\n"
+                "\nReturn information about the given dogecoin address.\n"
                 "Some of the information will only be present if the address is in the active wallet.\n",
                 {
-                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for which to get information."},
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dogecoin address for which to get information."},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
                     {
-                        {RPCResult::Type::STR, "address", "The bitcoin address validated."},
+                        {RPCResult::Type::STR, "address", "The dogecoin address validated."},
                         {RPCResult::Type::STR_HEX, "scriptPubKey", "The hex-encoded scriptPubKey generated by the address."},
                         {RPCResult::Type::BOOL, "ismine", "If the address is yours."},
                         {RPCResult::Type::BOOL, "iswatchonly", "If the address is watchonly."},
@@ -4015,7 +4015,7 @@ static RPCHelpMan send()
                 {
                     {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                         {
-                            {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
+                            {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the dogecoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
                         },
                         },
                     {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
@@ -4033,7 +4033,7 @@ static RPCHelpMan send()
                 {
                     {"add_inputs", RPCArg::Type::BOOL, /* default */ "false", "If inputs are specified, automatically include more if they are not enough."},
                     {"add_to_wallet", RPCArg::Type::BOOL, /* default */ "true", "When false, returns a serialized transaction which will not be added to the wallet or broadcast"},
-                    {"change_address", RPCArg::Type::STR_HEX, /* default */ "pool address", "The bitcoin address to receive the change"},
+                    {"change_address", RPCArg::Type::STR_HEX, /* default */ "pool address", "The dogecoin address to receive the change"},
                     {"change_position", RPCArg::Type::NUM, /* default */ "random", "The index of the change output"},
                     {"change_type", RPCArg::Type::STR, /* default */ "set by -changetype", "The output type to use. Only valid if change_address is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
                     {"conf_target", RPCArg::Type::NUM, /* default */ "wallet -txconfirmtarget", "Confirmation target in blocks"},
@@ -4055,7 +4055,7 @@ static RPCHelpMan send()
                     {"psbt", RPCArg::Type::BOOL,  /* default */ "automatic", "Always return a PSBT, implies add_to_wallet=false."},
                     {"subtract_fee_from_outputs", RPCArg::Type::ARR, /* default */ "empty array", "Outputs to subtract the fee from, specified as integer indices.\n"
                     "The fee will be equally deducted from the amount of each specified output.\n"
-                    "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
+                    "Those recipients will receive less dogecoins than you enter in their corresponding amount field.\n"
                     "If no outputs are specified here, the sender pays the fee.",
                         {
                             {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
@@ -4362,7 +4362,7 @@ static RPCHelpMan walletcreatefundedpsbt()
                         {
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                                 {
-                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
+                                    {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the dogecoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
                                 },
                                 },
                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
@@ -4376,7 +4376,7 @@ static RPCHelpMan walletcreatefundedpsbt()
                     {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, "",
                         {
                             {"add_inputs", RPCArg::Type::BOOL, /* default */ "false", "If inputs are specified, automatically include more if they are not enough."},
-                            {"changeAddress", RPCArg::Type::STR_HEX, /* default */ "pool address", "The bitcoin address to receive the change"},
+                            {"changeAddress", RPCArg::Type::STR_HEX, /* default */ "pool address", "The dogecoin address to receive the change"},
                             {"changePosition", RPCArg::Type::NUM, /* default */ "random", "The index of the change output"},
                             {"change_type", RPCArg::Type::STR, /* default */ "set by -changetype", "The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
                             {"includeWatching", RPCArg::Type::BOOL, /* default */ "true for watch-only wallets, otherwise false", "Also select inputs which are watch only"},
@@ -4385,7 +4385,7 @@ static RPCHelpMan walletcreatefundedpsbt()
                             {"feeRate", RPCArg::Type::AMOUNT, /* default */ "not set, fall back to wallet fee estimation", "Specify a fee rate in " + CURRENCY_UNIT + "/kvB."},
                             {"subtractFeeFromOutputs", RPCArg::Type::ARR, /* default */ "empty array", "The outputs to subtract the fee from.\n"
                                                           "The fee will be equally deducted from the amount of each specified output.\n"
-                                                          "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
+                                                          "Those recipients will receive less dogecoins than you enter in their corresponding amount field.\n"
                                                           "If no outputs are specified here, the sender pays the fee.",
                                 {
                                     {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index d1c46788846..16621ecbfcb 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -230,7 +230,7 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain240Setup)
                       "timestamp %d. There was an error reading a block from time %d, which is after or within %d "
                       "seconds of key creation, and could contain transactions pertaining to the key. As a result, "
                       "transactions and coins using this key may not appear in the wallet. This error could be caused "
-                      "by pruning or data corruption (see bitcoind log for details) and could be dealt with by "
+                      "by pruning or data corruption (see dogecoind log for details) and could be dealt with by "
                       "downloading and rescanning the relevant blocks (see -reindex and -rescan "
                       "options).\"}},{\"success\":true}]",
                               0, oldTip->GetBlockTimeMax(), TIMESTAMP_WINDOW));
diff --git a/test/functional/rpc_deprecated.py b/test/functional/rpc_deprecated.py
index a79aa12942c..39b851cbadc 100755
--- a/test/functional/rpc_deprecated.py
+++ b/test/functional/rpc_deprecated.py
@@ -53,7 +53,7 @@ def run_test(self):
             txid = w0.sendrawtransaction(signed_tx)
             self.sync_all()
 
-            assert_raises_rpc_error(-32, 'Using bumpfee with wallets that have private keys disabled is deprecated. Use psbtbumpfee instead or restart bitcoind with -deprecatedrpc=bumpfee. This functionality will be removed in 0.22', noprivs0.bumpfee, txid)
+            assert_raises_rpc_error(-32, 'Using bumpfee with wallets that have private keys disabled is deprecated. Use psbtbumpfee instead or restart dogecoind with -deprecatedrpc=bumpfee. This functionality will be removed in 0.22', noprivs0.bumpfee, txid)
             bumped_psbt = noprivs1.bumpfee(txid)
             assert 'psbt' in bumped_psbt
         else:
diff --git a/test/functional/rpc_fundrawtransaction.py b/test/functional/rpc_fundrawtransaction.py
index fe843396f30..e0654e2c61c 100755
--- a/test/functional/rpc_fundrawtransaction.py
+++ b/test/functional/rpc_fundrawtransaction.py
@@ -230,7 +230,7 @@ def test_invalid_change_address(self):
         dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
         assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
 
-        assert_raises_rpc_error(-5, "Change address must be a valid bitcoin address", self.nodes[2].fundrawtransaction, rawtx, {'changeAddress':'foobar'})
+        assert_raises_rpc_error(-5, "Change address must be a valid dogecoin address", self.nodes[2].fundrawtransaction, rawtx, {'changeAddress':'foobar'})
 
     def test_valid_change_address(self):
         self.log.info("Test fundrawtxn with a provided change address")
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 90f04d9ad34..368953353df 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -392,13 +392,13 @@ def run_test(self):
             assert_raises_rpc_error(-3, "Address does not refer to a key", self.nodes[0].dumpprivkey, temp_address)
 
             # This will raise an exception for attempting to get the private key of an invalid Bitcoin address
-            assert_raises_rpc_error(-5, "Invalid Bitcoin address", self.nodes[0].dumpprivkey, "invalid")
+            assert_raises_rpc_error(-5, "Invalid Dogecoin address", self.nodes[0].dumpprivkey, "invalid")
 
             # This will raise an exception for attempting to set a label for an invalid Bitcoin address
-            assert_raises_rpc_error(-5, "Invalid Bitcoin address", self.nodes[0].setlabel, "invalid address", "label")
+            assert_raises_rpc_error(-5, "Invalid Dogecoin address", self.nodes[0].setlabel, "invalid address", "label")
 
             # This will raise an exception for importing an invalid address
-            assert_raises_rpc_error(-5, "Invalid Bitcoin address or script", self.nodes[0].importaddress, "invalid")
+            assert_raises_rpc_error(-5, "Invalid Dogecoin address or script", self.nodes[0].importaddress, "invalid")
 
             # This will raise an exception for attempting to import a pubkey that isn't in hex
             assert_raises_rpc_error(-5, "Pubkey must be a hex string", self.nodes[0].importpubkey, "not hex")
diff --git a/test/functional/wallet_labels.py b/test/functional/wallet_labels.py
index d2fd7ede1ac..86a3ca7ce33 100755
--- a/test/functional/wallet_labels.py
+++ b/test/functional/wallet_labels.py
@@ -156,7 +156,7 @@ def run_test(self):
             ad = BECH32_INVALID[l]
             assert_raises_rpc_error(
                 -5,
-                "Address is not valid" if self.options.descriptors else "Invalid Bitcoin address or script",
+                "Address is not valid" if self.options.descriptors else "Invalid Dogecoin address or script",
                 lambda: wallet_watch_only.importaddress(label=l, rescan=False, address=ad),
             )
 
diff --git a/test/functional/wallet_send.py b/test/functional/wallet_send.py
index 957ff2e9b79..ea29c405369 100755
--- a/test/functional/wallet_send.py
+++ b/test/functional/wallet_send.py
@@ -337,7 +337,7 @@ def run_test(self):
 
         self.log.info("Manual change address and position...")
         self.test_send(from_wallet=w0, to_wallet=w1, amount=1, change_address="not an address",
-                       expect_error=(-5, "Change address must be a valid bitcoin address"))
+                       expect_error=(-5, "Change address must be a valid dogecoin address"))
         change_address = w0.getnewaddress()
         self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False, change_address=change_address)
         assert res["complete"]