Merge branch 'duke' into dev

11 months ago · 9d2720d118
28 changed files with 643 additions and 984 deletions
--- a/depends/packages/boost.mk
+++ b/depends/packages/boost.mk
@ -38,16 +38,16 @@ endef

 ifeq ($(host_os),linux)
 define $(package)_build_cmds
-  ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage
+  ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage
 endef
 define $(package)_stage_cmds
-  ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install
+  ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install
 endef
 else
 define $(package)_build_cmds
-  ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage
+  ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage
 endef
 define $(package)_stage_cmds
-  ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
+  ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
 endef
 endif
--- a/depends/packages/rust.mk
+++ b/depends/packages/rust.mk
@ -46,12 +46,12 @@ define $(package)_extract_cmds
 endef

 define $(package)_stage_cmds
-  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig && \
-  ../$(canonical_host)/install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig
+  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs && \
+  ../$(canonical_host)/install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs
 endef
 else

 define $(package)_stage_cmds
-  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig
+  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs
 endef
 endif
--- a/src/addrman.cpp
+++ b/src/addrman.cpp
@ -143,15 +143,17 @@ void CAddrMan::SwapRandom(unsigned int nRndPos1, unsigned int nRndPos2)
    if (nRndPos1 == nRndPos2)
        return;

-    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
+    // assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());

    int nId1 = vRandom[nRndPos1];
    int nId2 = vRandom[nRndPos2];

    const auto it_1{mapInfo.find(nId1)};
    const auto it_2{mapInfo.find(nId2)};
-    assert(it_1 != mapInfo.end());
-    assert(it_2 != mapInfo.end());
+
+    if( (it_1 == mapInfo.end()) || (it_2 == mapInfo.end())) {
+        return;
+    }

    it_1->second.nRandomPos = nRndPos2;
    it_2->second.nRandomPos = nRndPos1;
@ -167,8 +169,8 @@ void CAddrMan::Delete(int nId)
    const auto it{mapInfo.find(nId)};
    if (it != mapInfo.end()) {
        CAddrInfo& info = (*it).second;
-        assert(!info.fInTried);
-        assert(info.nRefCount == 0);
+        // assert(!info.fInTried);
+        // assert(info.nRefCount == 0);

        SwapRandom(info.nRandomPos, vRandom.size() - 1);
        vRandom.pop_back();
@ -189,7 +191,10 @@ void CAddrMan::ClearNew(int nUBucket, int nUBucketPos)
        const auto it{mapInfo.find(nIdDelete)};
        if (it != mapInfo.end()) {
            CAddrInfo& infoDelete = (*it).second;
-            assert(infoDelete.nRefCount > 0);
+            // assert(infoDelete.nRefCount > 0);
+            if (infoDelete.nRefCount == 0) {
+                return;
+            }
            infoDelete.nRefCount--;
            vvNew[nUBucket][nUBucketPos] = -1;
            if (infoDelete.nRefCount == 0) {
@ -217,7 +222,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
    }
    nNew--;

-    assert(info.nRefCount == 0);
+    //assert(info.nRefCount == 0);

    // which tried bucket to move the entry to
    int nKBucket = info.GetTriedBucket(nKey, m_asmap);
@ -227,7 +232,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
    if (vvTried[nKBucket][nKBucketPos] != -1) {
        // find an item to evict
        int nIdEvict = vvTried[nKBucket][nKBucketPos];
-        assert(mapInfo.count(nIdEvict) == 1);
+        //assert(mapInfo.count(nIdEvict) == 1);
        CAddrInfo& infoOld = mapInfo[nIdEvict];

        // Remove the to-be-evicted item from the tried set.
@ -239,14 +244,14 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
        int nUBucket = infoOld.GetNewBucket(nKey, m_asmap);
        int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);
        ClearNew(nUBucket, nUBucketPos);
-        assert(vvNew[nUBucket][nUBucketPos] == -1);
+        //assert(vvNew[nUBucket][nUBucketPos] == -1);

        // Enter it into the new set again.
        infoOld.nRefCount = 1;
        vvNew[nUBucket][nUBucketPos] = nIdEvict;
        nNew++;
    }
-    assert(vvTried[nKBucket][nKBucketPos] == -1);
+    //assert(vvTried[nKBucket][nKBucketPos] == -1);

    vvTried[nKBucket][nKBucketPos] = nId;
    nTried++;
@ -499,7 +504,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
                    MilliSleep(kRetrySleepInterval);
            }
            int nId = vvTried[nKBucket][nKBucketPos];
-            assert(mapInfo.count(nId) == 1);
+            // assert(mapInfo.count(nId) == 1);
+            if(mapInfo.count(nId) != 1) {
+                fprintf(stderr,"%s: Could not find tried node with nId=%d=vvTried[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nKBucket, nKBucketPos, nId, mapInfo.count(nId) );
+                continue;
+            }
+
            CAddrInfo& info = mapInfo[nId];
            if (info.IsReachableNetwork()) {
                //deprioritize unreachable networks
@ -534,7 +544,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
                    MilliSleep(kRetrySleepInterval);
            }
            int nId = vvNew[nUBucket][nUBucketPos];
-            assert(mapInfo.count(nId) == 1);
+
+            if(mapInfo.count(nId) != 1) {
+                fprintf(stderr,"%s: Could not find new node with nId=%d=vvNew[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nUBucket, nUBucketPos, nId, mapInfo.count(nId) );
+                continue;
+            }
+            // assert(mapInfo.count(nId) == 1);
            CAddrInfo& info = mapInfo[nId];
            if (info.IsReachableNetwork()) {
                //deprioritize unreachable networks
@ -655,7 +670,7 @@ void CAddrMan::GetAddr_(std::vector<CAddress>& vAddr, bool wants_addrv2)
        if (vAddr.size() >= nNodes)
            break;

-        assert(mapInfo.count(vRandom[n]) == 1);
+        // assert(mapInfo.count(vRandom[n]) == 1);
        const CAddrInfo& ai = mapInfo[vRandom[n]];

        if (!ai.IsTerrible()) {
--- a/src/cc/assets.cpp
+++ b/src/cc/assets.cpp
@ -150,20 +150,6 @@ bool AssetsValidate(struct CCcontract_info *cpAssets,Eval* eval,const CTransacti
    outputsDummy = inputs = 0;
    preventCCvins = preventCCvouts = -1;
    
-    // add specific chains exceptions for old token support:
-    if (strcmp(SMART_CHAIN_SYMBOL, "SEC") == 0 && chainActive.Height() <= 144073)
-        return true;
-    
-    if (strcmp(SMART_CHAIN_SYMBOL, "MGNX") == 0 && chainActive.Height() <= 210190)
-        return true;
-
-    // add specific chains exceptions for old token support:
-    if (strcmp(SMART_CHAIN_SYMBOL, "SEC") == 0 && chainActive.Height() <= 144073)
-        return true;
-
-    if (strcmp(SMART_CHAIN_SYMBOL, "MGNX") == 0 && chainActive.Height() <= 210190)
-        return true;
-        
 	if (numvouts == 0)
 		return eval->Invalid("AssetValidate: no vouts");

--- a/src/cc/import.cpp
+++ b/src/cc/import.cpp
@ -672,9 +672,6 @@ bool Eval::ImportCoin(const std::vector<uint8_t> params, const CTransaction &imp

    LOGSTREAM("importcoin", CCLOG_DEBUG1, stream << "Validating import tx..., txid=" << importTx.GetHash().GetHex() << std::endl);

-    if (strcmp(SMART_CHAIN_SYMBOL, "CFEKDIMXY6") == 0 && chainActive.Height() <= 44693)
-        return true;
-
    if (importTx.vout.size() < 2)
        return Invalid("too-few-vouts");
    // params
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@ -1553,7 +1553,529 @@ void *chainparams_commandline() {

                };
                // END HUSH mainnet checkpoint data
+        } else if (strcmp(SMART_CHAIN_SYMBOL,"DRAGONX") == 0) {
+            checkpointData = //(Checkpoints::CCheckpointData)
+                   {
+                            boost::assign::map_list_of
+                    // Generated at 1686858269 via hush3 util/checkpoints.pl by Duke Leto
+                    (1000,     uint256S("0x000bffdae30339fad4ed82a2d2bfc0846f12fb9aeef5e33bb563f4cdd376dc08"))
+                    (2000,     uint256S("0x0003578c68350c7afacdc940c87ea9255681a135a0a9b2c13a075485d96155ed"))
+                    (3000,     uint256S("0x0001fef5443794fe61e0d397897f0a45a66c5473a70819608504f1395aed1d8c"))
+                    (4000,     uint256S("0x000197510698c8fc50133971744d1dd49aae371366d3986c412a189e9c617974"))
+                    (5000,     uint256S("0x00000094754d610b08b801545dbdbf57433e7c4d2a48818ff499f8fab05b0927"))
+                    (6000,     uint256S("0x0002116377d2d0c04344f0ed7eec63814b54bae740562ccede0c3d9404900cdb"))
+                    (7000,     uint256S("0x0001c74d83479bf05a3d9181555ff4ed373a642b1b4cb9cc633c090a522c10e0"))
+                    (8000,     uint256S("0x00011c3cd9aeadb039ba28547f232391ded0329ab6b7ec454aeb671246c94b58"))
+                    (9000,     uint256S("0x00005b1b0187ba523b6670e65262d1b028a140582301c7ea65065cd47a679c6d"))
+                    (10000,     uint256S("0x0000f32ac2bd4581ef4b651f72b27d92dfca04d4dc721c505214f113e209b10e"))
+                    (11000,     uint256S("0x000086e271117d75ac85fd00fbec94bbc53a5b990ccb362a8a2f064a97cdf7b2"))
+                    (12000,     uint256S("0x000098431effc021e44f867cffa2e309d7bbcc34201ea8d3bc7b08faeca556e3"))
+                    (13000,     uint256S("0x000194c6d37ebd00f7746536a7f3a891866954c1020f61be5573b055ea991fa1"))
+                    (14000,     uint256S("0x0001102d2b0c1efe8c07768b3bd540e8b2ef8c03e2f8271a58def634a51c576f"))
+                    (15000,     uint256S("0x0000c616068d8730adbd87b2bc9d4d5322610e52da6806b9cb2f1894af37d933"))
+                    (16000,     uint256S("0x0000049f6a5818a48aafb52781f91f8eca4d05c29c537a85c34b6fa342996a27"))
+                    (17000,     uint256S("0x000079bf17272dc67ca18df9f7c5b817c37bd2d103ee76d3b2271511c5aa0b82"))
+                    (18000,     uint256S("0x00005f4d742dc1b0e12200c4da8080d75973b18b6d2bdf748f149be72a313627"))
+                    (19000,     uint256S("0x0000368eaee2a6f22d64c66c0e3cfc7fe2709f7ced31a589ac8b4c461eca2fff"))
+                    (20000,     uint256S("0x0001b4057aebdc835c63dfb581235d5917af697fff962ecfe47e8a26c0b3ac55"))
+                    (21000,     uint256S("0x00010a339a0830471d384741ff24161252fdfab8ecfb493b6e8d1f1e7ce342b7"))
+                    (22000,     uint256S("0x000013c834a72926969cf8ed88b79175aa3ea952e67b7054c4fa06cc4e5209c4"))
+                    (23000,     uint256S("0x0000386a639d79d35972576b55787a80986a27c7415949dc645dc50522f6487a"))
+                    (24000,     uint256S("0x000075055db90559920ac02c2de8e1622533b7532b84fe702baf05082161e011"))
+                    (25000,     uint256S("0x0001b866113317839d2f6fa608f98f798db1570b4f84e36789126edda9b75d35"))
+                    (26000,     uint256S("0x00012ce8394b99c4fff5c052a0abb142c8c1eaa58b830699222a8eacb95298af"))
+                    (27000,     uint256S("0x000058bbe34298518632e0522d3ba10e050a5a31e2c4fd862a576f300e9f5c1d"))
+                    (28000,     uint256S("0x000163c608d28f1c3a10f8425b5469099b7fff50e25424659887e011d2c0281e"))
+                    (29000,     uint256S("0x0000c3baca291f20849d96de3436dad0efc24aa5b44bbdd466ea841b28d70a2e"))
+                    (30000,     uint256S("0x000075d2e08eafd62f4633cc1cabf281de17e7e0bba7965db75f3cf268b9a980"))
+                    (31000,     uint256S("0x00010cc563eef842749ea14412e922bad6e3515c049f639612a07b221aff4de2"))
+                    (32000,     uint256S("0x000150dee2380f76bb144f8c5433bd27e049c54feaaeadeb8bfc3948293453a9"))
+                    (33000,     uint256S("0x0000ec245f9808c6792915ae2a467593a1675efce42a2d0ee486e091913159d8"))
+                    (34000,     uint256S("0x000166dbcd4f262032e7a981207ac709f7be88a037650ca454db43018286c8f8"))
+                    (35000,     uint256S("0x0001a5c13dd9333a4ec60bc6af488ef7e3738aaf2170c70b716a30597b8e2d70"))
+                    (36000,     uint256S("0x00018e4fe65c96f0e187c265fa3faa49156ad07991284920beaef3b3b499dcbe"))
+                    (37000,     uint256S("0x00017e952f47ea070893b41a76468fee7db3073184eab10c960e2aead6fddf7e"))
+                    (38000,     uint256S("0x00010e3c64c0127fb995ab10d45bb281e5c78239c0303c825d81bb4cf994c7c0"))
+                    (39000,     uint256S("0x0001db8de504639d87029c9be04acdfef038601af58ea38ba307a7cc0ce8fdf7"))
+                    (40000,     uint256S("0x00015fc2f6953e67578c6484c3a5342d883fd3ef051456edc55064e544f04df2"))
+                    (41000,     uint256S("0x000200e23bc81ee9e9a9b29eb9c478c035d52de845c118a1645a3876d0f0f7ec"))
+                    (42000,     uint256S("0x00018b8b952e0268ee7007ca2bfe3499f1c78911e5d308d877aa3829a8ddfa95"))
+                    (43000,     uint256S("0x00005cc6dc81cdd3ad3c1bc5675064b8d6d01ac85348c116f4db28c61df5cb52"))
+                    (44000,     uint256S("0x0002a71c4a45353eeed81519d1f4b78e4be13702907bc872fd605c094eb5c8fe"))
+                    (45000,     uint256S("0x00005c3e9bdb78fa205f39a6f4fff5c547775ee90e79fedebecb17336c03e868"))
+                    (46000,     uint256S("0x00024017e7985c841e8b607624f74f3efe46f915d272f9f8c07a93353858d92b"))
+                    (47000,     uint256S("0x0000d29c58bb338aa55bb017d8fbbe3b7c3bed83f212094a18ef7fde7f8eb675"))
+                    (48000,     uint256S("0x00024b1c2d6131f7ec9748c763c3168d2d761c7617e10d09fb93aff2b4a29ca3"))
+                    (49000,     uint256S("0x000120f81110878ca7ec75d155badf2348bda20a9034b24b8317ba0f16568788"))
+                    (50000,     uint256S("0x000207bddb3ebb7cb8000f84e63ae7be40e74dde52c8bfa4f0cc913b048e5767"))
+                    (51000,     uint256S("0x0001c8554ac45a19684c7328056420d7b27c1c5c9f03059c095ca4a2749b29f4"))
+                    (52000,     uint256S("0x000104d93b769e9e7190b031f6250445b05750a36231f8ea7f2dce8c8a0487be"))
+                    (53000,     uint256S("0x00002ab5a1e72ef163242f4be6a26063f26cef6f1eccb4cfe44a099ba710fdc4"))
+                    (54000,     uint256S("0x000117645f0ee76f12601abe5554729ca9241c65e49cbefae77e67d18204795f"))
+                    (55000,     uint256S("0x0000ab7cf81435f26f56b9687b8f6feaaed95ed8090a1dac8a690a39b9a89c8b"))
+                    (56000,     uint256S("0x000134d8809fb2222a3ed76958f998589ac69d6d08d534309ecf569b6d448cb3"))
+                    (57000,     uint256S("0x00003daaec8c3d9c31b32163cef47c4883ad9b12b85a641eefbd02b06c4b6083"))
+                    (58000,     uint256S("0x000096456c3f1af39489df84dbf0a0975c9cc29fa1f524e72cf4421fd6465b82"))
+                    (59000,     uint256S("0x00016202a3cdcb3b0c27e75f84cebcf576bc7869abf0fab13c68abd3b111fb9e"))
+                    (60000,     uint256S("0x000071cd818c3fa9f155ec8ac65333f43e0d86b4f6ea98fc702ae0fe1ec3126f"))
+                    (61000,     uint256S("0x0000d1654355ba77105cc07e7cf024e0200f39646ea3cbf816737e621857ff36"))
+                    (62000,     uint256S("0x0000f1e6a09effa09329175ee4d8b42fdae3c365f1232fd440d0d41b6c090dc9"))
+                    (63000,     uint256S("0x0000ffbceee7b86cb04a37fefeb0452de8305aef4c37b6bfa84cffe4dba168be"))
+                    (64000,     uint256S("0x00002db24701b3d6c0d7547c1636b0aae754c050915ba607da1022e859bf0a07"))
+                    (65000,     uint256S("0x000102bfa6361b71cc51e231b87c653dfd21a865284fe013d65bac8fb2d96878"))
+                    (66000,     uint256S("0x000061e9bf36f9b2d110d7d545d9fa1deaaf39ce91d2d5e3f51b5e8eec37d820"))
+                    (67000,     uint256S("0x00000128e4528bae30aae739e7d1d1528e366739878878bdec5e5d5f5639de21"))
+                    (68000,     uint256S("0x0000c45a027fe81eb60c60573bffa4558b3d187f7144131eff0b97fc52d8fbcf"))
+                    (69000,     uint256S("0x00005fc22d9c90e1c88c5724ea8b45d2b198bd03d77931c4d328e88313d9080e"))
+                    (70000,     uint256S("0x0000bbfd71d248074239456adf756eff007bcbe004b8c02eed8dd1b1656d9270"))
+                    (71000,     uint256S("0x00003f2d633d303c935554a414ec99443e01f5e626522159d97b7774f939158f"))
+                    (72000,     uint256S("0x0001514d0a98b94dbc81f70c59d29ae437a4690beb464d1b92abe7bd1e055a35"))
+                    (73000,     uint256S("0x0000807fe075a08da2bb07b8f4bb9a02b7e450fe6e5be062c21b15beed210dfa"))
+                    (74000,     uint256S("0x00006bf606a3c548c55c079343183caaebaa2c23d8580abb9eedf2a7e9b2a453"))
+                    (75000,     uint256S("0x00016da1e267ef35372482c84a37012e74c136fea0015b48ac7e039a5025b71e"))
+                    (76000,     uint256S("0x000029e02c641075abe8adabdb3b59e3696611f37c3da3f3bfcad72a705e7a3c"))
+                    (77000,     uint256S("0x000105f3af93470b7076fdfb9a0e9714f596ca4366deb3c35333648257464d67"))
+                    (78000,     uint256S("0x000144235c2eb2e871e11eca2ef9c051432bce4e9a1bb346b0b895e8e559286b"))
+                    (79000,     uint256S("0x0000b73f9f1a91cacb3c93638fe7ef6fa91072fd76d91cb51f34e794941f7325"))
+                    (80000,     uint256S("0x00001d995acdf7ac796829dcc869dae073258e5c608a8daa709b4c512c3a3343"))
+                    (81000,     uint256S("0x0000b163da6072538fc53a789dc47228a691b734a74e551e0e2e9e0d26fdbcff"))
+                    (82000,     uint256S("0x00012e9491a6d4d2b32f1869eb44672e1833ab718e580bf5609d7f9c58bc0af3"))
+                    (83000,     uint256S("0x00017280176966d19319f3c4d67440759e072e0c8b66b93d1f87921743b99fd1"))
+                    (84000,     uint256S("0x0000f62cd78630155998d1a64104c2f66328a586988b18874e99364eb60fc0d9"))
+                    (85000,     uint256S("0x00000d6fe7b9dec442628066442bd0558ceaa1a8d664d82f122790b2c917f950"))
+                    (86000,     uint256S("0x000029a1d545e5b7fdd28617de6195347d719524d5626f12d19924921e7f2359"))
+                    (87000,     uint256S("0x000138aea3caee3827eacfea9efd4d41f74958992c3b17a19599c28932aec442"))
+                    (88000,     uint256S("0x0000ace521b7b212027faf886832a3858b6b1391face5d9bfa21a58d08577f17"))
+                    (89000,     uint256S("0x000054190734e754a5aa58f1cb70753fcba0a88f512185578b8d772918dbf549"))
+                    (90000,     uint256S("0x0000d841407e0ac42c190ca65319bf2c4ec056724c75774bbfaaaf28fc022fec"))
+                    (91000,     uint256S("0x0000d95e5a72eb25762fd65ed7901ee7c5365d1b7ada72080743f95fe9bfd308"))
+                    (92000,     uint256S("0x0000c77b274f557cca7a381b64ccba1412a4f927ae850cc5e0ea3b3fe6a85947"))
+                    (93000,     uint256S("0x000006ce04d80995709a8a93da2eaa6c00a7b0c15e7f409a1cbfa64f92ec4aee"))
+                    (94000,     uint256S("0x0000e610317357e75beadac9a249f9b1847e26d98dfde191f9e421df0ac009ec"))
+                    (95000,     uint256S("0x000039e0566bdb30c72857c5e05afeefefcb4fea69ee24e86fb3506c93c4169a"))
+                    (96000,     uint256S("0x00007707c899da1d86457bc55fc614cef6dfc73216d04f26b500728c57b8b7c6"))
+                    (97000,     uint256S("0x000133c725bdbbf3c4c3669e32f459f3d0cb6c473b5a9dcfac06c486e1ece294"))
+                    (98000,     uint256S("0x00001d75a7c92f3586045b534f5a80c474b9b1ba463acd1462b9494bc9dbc12d"))
+                    (99000,     uint256S("0x000070946880c634b930804e55cc2f380fbd897d4d1713e6ab0a86ec66299f44"))
+                    (100000,     uint256S("0x00005af032270f04bc9be8072ee0b70820b88303dc25770a8dfb5c6f00341ae8"))
+                    (101000,     uint256S("0x00015739048f9cd91a5f5da04d9b1f0b220d719c13a6b03577d60027ba0cf130"))
+                    (102000,     uint256S("0x0000ae124051763e3ccdc1beff5d4ba304715e06f6a54124ee4ce4a4424e2925"))
+                    (103000,     uint256S("0x0000b46bd79314799b28964e5bc9cfbfd4481fd4148c4775337cc7a3458f411f"))
+                    (104000,     uint256S("0x0000546d926811aeaa19b14fb06c919174d73ceb41800f21e8856b940ea0d51e"))
+                    (105000,     uint256S("0x00006f831295c6d417a10268beda28ef058a646d68dcf53f6c5197c7c0071144"))
+                    (106000,     uint256S("0x0000aa4f504584b2e604186eb4edc1d60caa757ef25db86a35aca9b9e03bab02"))
+                    (107000,     uint256S("0x0000e945fef42d3eb4cc606aa888cb9908a9778592470e6630035821b83bf32a"))
+                    (108000,     uint256S("0x000042b833a40904ba608c715efca50f3b351924cddc50793af26be698b791b4"))
+                    (109000,     uint256S("0x00008b8778ff887a3ae0dc04a9cc546408c8b7cc4f23668b2e38ade6fbe31487"))
+                    (110000,     uint256S("0x00007558a72be2b93ff9c32a3c8c8896f4fd7b8d59430a1917755412307bbcde"))
+                    (111000,     uint256S("0x00005fcd2934faee4f6cf128a272a03c7001be0f59abe873c4ef5dbd469fee67"))
+                    (112000,     uint256S("0x0000ea01486382afa2787d723f80d1073bd8924181f9e0aba2e4a253e4fb571d"))
+                    (113000,     uint256S("0x00002e5f65baec8b526c5096351a30bc33cee3692ed4e3b4144229cf9ca6dc83"))
+                    (114000,     uint256S("0x0000177996f4e8f436672b0405b1de6bb7335bdc32cea1635d6122c4d6af7563"))
+                    (115000,     uint256S("0x00011891d2d508824de7657981c754372a2c2985b2d483fc48003de27f9b5716"))
+                    (116000,     uint256S("0x000088d8381d4a1c3b468bedbf6320e7dba41285ae99bcaf0b4750ca9cada4bb"))
+                    (117000,     uint256S("0x0000b0dacbd93ed6feb0c83af3f8b57598ca9b59b87c4a0f6f8b7738b37ba280"))
+                    (118000,     uint256S("0x000141aa854c151264db40b7fb065d5d6402c03786d1201a428bdb2f3cf4be0d"))
+                    (119000,     uint256S("0x00001dcec0e976c13fa307ee80f37a7d188e80b7e18c6aa744948139090ee4c6"))
+                    (120000,     uint256S("0x000159aac0c2854248eeaa7717b5f9defed70ec7eb56225f74650e2e4dd14ab0"))
+                    (121000,     uint256S("0x0000ffaabd57940430c76493f65b2ea9588ea5d218bf4ab8cd7986a4f36d85ed"))
+                    (122000,     uint256S("0x00004997285f83bdf2b84e906a5427d1246d2a9576fe70ba98db0fb1906e2a81"))
+                    (123000,     uint256S("0x00011189d192349030a4d667504557de1c6f321c2d2b433f279d83aefd49a88d"))
+                    (124000,     uint256S("0x000021e928fa16624a41e6d5d3275ecbf15d4f2e7ac529f411c071090b01a501"))
+                    (125000,     uint256S("0x0001678ffaaf26a44aacadf79d4312a1a3269e110df6a25b00371575574c5fd5"))
+                    (126000,     uint256S("0x00014435157bc5cf46047a2080a3fac7680635b4bd269404297581b884f26aff"))
+                    (127000,     uint256S("0x00005b0ee65fba4d6eb0902766eadf515fb252b86140e9093d249d8f9a54a128"))
+                    (128000,     uint256S("0x000021b7d3534640ec2854c0fcc08b1342162770a4e1c37870e9cf0030582d85"))
+                    (129000,     uint256S("0x00009fb144dfe588c1ae56ba6e17a6d6b1565c1b27464c5cba79c918b56a1760"))
+                    (130000,     uint256S("0x0000674dcced99276e684e9ac19eb2412e55c968a2bb524069384647cb45eefc"))
+                    (131000,     uint256S("0x0000ad841440e59715c68856f4011e854031cad19788438bdceaa4ca161f06a1"))
+                    (132000,     uint256S("0x00002789aed78f0b29396c9d654c1599b35cae19704d1b15e4f266af109c1f8c"))
+                    (133000,     uint256S("0x00002a422e40e72b7a35d4818a59297bfdcc5efcaeaa30d54d1d290e85a6f1de"))
+                    (134000,     uint256S("0x00003628a789756f15bb46fd8de99f9baab50f19a935716785dcae0275bf4a05"))
+                    (135000,     uint256S("0x000075517e8be4c0ed800d66ad00dd67346ea2b34348e594b769fa9bac3fecb5"))
+                    (136000,     uint256S("0x00002b4196ca58d9e2b7c75f1e8de291cf22b7bbc4be8dc2cfb29f54c256d3ba"))
+                    (137000,     uint256S("0x0000180d66e02d24330e9ef3d49813136eac06802e2989fa379d7a88e4067e01"))
+                    (138000,     uint256S("0x0000ad0a51cac855e0b162fbf069b560cd8d21fb5275f9d06304a740129bc809"))
+                    (139000,     uint256S("0x0000219d48ec853516f9262b41d84c5fbc5417b604e3b9001769bd5ac3f59b28"))
+                    (140000,     uint256S("0x00012475b06db9b0c4befe66ed3de054b993bc787092488df2383c566155921e"))
+                    (141000,     uint256S("0x000061896c62d282efc098341741a1a67c4d9c87fec6f1948a2225bc56c44c78"))
+                    (142000,     uint256S("0x0000444880b2e2b46b874fbb0acd44675ce257d2bac4eade4b9b9929a7b39b08"))
+                    (143000,     uint256S("0x0000509c13924e0733c5d6fc3bc7a270d2dd3b4c82db7fdfcaf02a410103ca78"))
+                    (144000,     uint256S("0x0000dd507d1b7059fb9c41c103ff43190425d567a661a59d704563c9dce1a1c9"))
+                    (145000,     uint256S("0x000097e5ebd34461ebcb5fdd3beb6e973fa752817f2ebe9fd3d57a56537e1ec0"))
+                    (146000,     uint256S("0x0000afb0eab0639d2623a15d8454cc7464c83f677fa7461259a445304fc3d3a8"))
+                    (147000,     uint256S("0x000123ce32adbc6c65e490bcc21554b0afda1476b2a6da11a28e264f1964cda6"))
+                    (148000,     uint256S("0x00016278bed29b081e4986de9c6422a89d8aa719dd1ab422c1ea7fa10284094b"))
+                    (149000,     uint256S("0x0001484305013531de1e5abda094fb453d5c5fb0d35812327ea01517c9149cdc"))
+                    (150000,     uint256S("0x0000da3a58875dc171e5bb9747cff5dfa2880d39e244d3f10acccf5232aac81b"))
+                    (151000,     uint256S("0x000006f333c55d2b6ab5f334a6d05f96fe74e301d4110ac92807239873f25671"))
+                    (152000,     uint256S("0x00008844695c54bee8e1711ec7e80f474c7a3bf1b78aa272553ca233746c912f"))
+                    (153000,     uint256S("0x00011c8bc4ffe00ea899ae19daa572e61e4cb951a594229d67e2af19d6388d21"))
+                    (154000,     uint256S("0x000111aaabb95e1cb1a225e5e8b2a6727c11da97c7391800618c7ba11c6ad669"))
+                    (155000,     uint256S("0x0001011a4d88acf916da949572a7f1c208bd7d31e0598d4337980c48ed88b18f"))
+                    (156000,     uint256S("0x0000651ee0d6bdaeec5bf585fa628e4336e7238974ca90461d38506c34d6f00b"))
+                    (157000,     uint256S("0x0000d2ecfe64aa069aeba21fb1bd8995cfad455c296670e3dec13fde989aa1c5"))
+                    (158000,     uint256S("0x000113b2ab0d24a2bac410a0155ca9d2fa6b2923c0042c228dd86fe37ad04469"))
+                    (159000,     uint256S("0x0000b1741e1d0b841bf0c0d5b3a0b9a906cde8e630e10b71ebfdf18ae5197d9f"))
+                    (160000,     uint256S("0x0000419b54cbe8a842b92201996bd74382b63db7ab0b1989b932ecb19bdd6f4a"))
+                    (161000,     uint256S("0x000076eac68434f40b6921b251fc2ec5de4748044d849887a70116f344f1477c"))
+                    (162000,     uint256S("0x0000fb948303f30cde6c2ed932915e0f6aaa932dc3dec324851b256e82f4f2a0"))
+                    (163000,     uint256S("0x000025244341c537faf365bb46626f0283a2fc0cd668c93cb9771da7f7c6be56"))
+                    (164000,     uint256S("0x000046fc2919f8ae4b88c1faecea97f6301a27a9a16184934d70b0b305891a14"))
+                    (165000,     uint256S("0x000116cc086ac32a24092d39089d2bcf5977bbc08ad916a8fac2aaefb48f2220"))
+                    (166000,     uint256S("0x0000dc6455e6eaae079ba6592fe0d5688c696955f00d33dbfc0cf76aac48e10a"))
+                    (167000,     uint256S("0x00012685e23a0997797098d047631fe7da1849e763dda0c7a00f47c7dfd13366"))
+                    (168000,     uint256S("0x0000b28813965516fe96909418dc72a4ce126401cd7a03919b9888d0da3b37d3"))
+                    (169000,     uint256S("0x00014522bcc0fa9995c6b1b6e6ba3ddd4298b0dd59854d25e713c43778d93d77"))
+                    (170000,     uint256S("0x0000f8e02172873f12b2b1adf8709b5d1990ef64b674fb0e5ed1ea08db9b6a48"))
+                    (171000,     uint256S("0x0000b0d9d1cced1c0396bab1f1003c9a009dc47da63c8220fc23bb3948a82ed2"))
+                    (172000,     uint256S("0x000099c8db9b14c2d5f7c685ee8569755bc50306397f749c7e0e31e709bfc4f3"))
+                    (173000,     uint256S("0x00007c422bc9f8295deeb35ea5225bc4f8021fee412c9a5127b6067582b356fa"))
+                    (174000,     uint256S("0x0001127a0d14aec0b5ba96dfb606cb9a562d5dafe79646076b9c0a7f7bbc8ffa"))
+                    (175000,     uint256S("0x000091c16ae7ffb036f716ac975bf6a9572fd9d439abef21036d18c3be0f90c7"))
+                    (176000,     uint256S("0x0000f4e7f4a42a9bf0dfe831764ccf9a8116f98e8158d072b8034d6b7a1e0400"))
+                    (177000,     uint256S("0x00006a9efe8a6d93dc8d16757a425c2cb8b910195f08fa210bb0bb3daec47080"))
+                    (178000,     uint256S("0x000065fdff26f07f13a0e9db44f6847161b360a6dea1cb7ef810c93a62043025"))
+                    (179000,     uint256S("0x0001a0a5300ed334e0ada6eb53d762ebcb1bf7ad0b6312905257f7698477ed51"))
+                    (180000,     uint256S("0x000131b050c745484f85e2c8422bf4624f23c69969d1c7d2f6760ef62a864746"))
+                    (181000,     uint256S("0x0000cf46ed02cc030fa3209a7fdca35a99249a17b241d30849ea094cdc827a49"))
+                    (182000,     uint256S("0x0000b16cd4ef9db7e929372be056e12d8422575891d032298cc17853d043a6e8"))
+                    (183000,     uint256S("0x0000d5d53dbb045bedbd997855eb931d7e671740e2aa37a84e184b43b90cf1a5"))
+                    (184000,     uint256S("0x00010f06fdae2de13519604475ff9412eb67731f9d4d0420c00b1f2530a5fd91"))
+                    (185000,     uint256S("0x000145be18021effbc081d0ca8fd549317766b57d828bc946436e84325b17c7c"))
+                    (186000,     uint256S("0x00006e592793a9bb5795a4f76b5ed47af4ce51b0d2e6730888c2c38dca5864b2"))
+                    (187000,     uint256S("0x0000438bdd8a024ccc008726a1690873039153df76ed254d2d773e55def68742"))
+                    (188000,     uint256S("0x00010108fe7c2543e5b258ee511ded17e12f3ed1688164ef78526684c1ea193e"))
+                    (189000,     uint256S("0x00005cc59b9b2116afa0e6ecc12769ee5f91efa91d245fc64bfda90479f8c9a7"))
+                    (190000,     uint256S("0x0000572751fda233f466c6ad237184ff6a7a15f8d84e5471e3dc5288ad74f592"))
+                    (191000,     uint256S("0x0000b5bb7236376176640e75308466cec3c3fa7bde6f24b1d12c96e94df2bb58"))
+                    (192000,     uint256S("0x0000620eaa310878ce85d6cd90d2b4724b36236575ff26c2ed6e34c93f6a8625"))
+                    (193000,     uint256S("0x00003a8b7d4cc3a92bb3b5301f9d7ca91941150e5bbc10f1204ec0175053bae2"))
+                    (194000,     uint256S("0x00007144b1bd53defd4cc1e78832a2bec8d66e094a0f03c22276e846cf8b598e"))
+                    (195000,     uint256S("0x00010530fcae36dc749c679366101df5d344243238e0e6dff2cbf57f9e25d5ce"))
+                    (196000,     uint256S("0x00002d2b003cc4851f4950cdfe7996f55b26c7564e60feb6e19597db49dd998b"))
+                    (197000,     uint256S("0x00011545798a62155ff5aa047a1cb59c0860b187a59bce8976b57f9c3bb35184"))
+                    (198000,     uint256S("0x000061433820de56f44eb774c2f54181b0e6d1e6b27e4a8eefef90039bbecd07"))
+                    (199000,     uint256S("0x0000403ced11ef43d8324070ddc30fc69a0c2d8186e4551c140a9378f0312d34"))
+                    (200000,     uint256S("0x00009ca9950079d5cd882b615fc068df25beed137642b751b224d6a939a87c69"))
+                    (201000,     uint256S("0x000015eb67778c671b0fd29016482d42758cc2edd8361f30788ab95c8328efa5"))
+                    (202000,     uint256S("0x0000c6e1a58b63e282fdedf31c1da7cc6d8b0a6dad82fc425672ac0eaf737c84"))
+                    (203000,     uint256S("0x000078e0e23fa6f7ccf5e8bb8d6703e0d70b7a86fc0c7493f61ef57e945a8250"))
+                    (204000,     uint256S("0x0000451704df4c8a94edd50b78540e8852bb55eef42bf2da3e19a173b8c246d5"))
+                    (205000,     uint256S("0x0000309772c01eeda1979e18f93a8721bfdd08c1796ea3a5861011c3de0f9fc1"))
+                    (206000,     uint256S("0x00001ba8aa17a23a2c6af771063cbe0afba5bed5b9a7b6c12d3cf0240277fa39"))
+                    (207000,     uint256S("0x0000bc3893889caddd09c6117bbd6dd044ebff10b28e008f19f7c43a496592fc"))
+                    (208000,     uint256S("0x0000684467ca15f917315fbab3fc3f2907c5f30153c5b884d0298a0d1e77815a"))
+                    (209000,     uint256S("0x0000a4f86f394beec9c9241e6dcb05b49393653bc5eaf35820403e54a23bcab6"))
+                    (210000,     uint256S("0x000097146b9280bac0344dc886cc4c77141b7467e2ef68e657525d789a9cdcc1"))
+                    (211000,     uint256S("0x0000298926d49fc5da4f866133c5c1d1e48d10a17b384eac616022057a7a46c9"))
+                    (212000,     uint256S("0x0000eca72307d64a15d234ee372e18862a46d6fc7fd2d0ef3d35c0e5ac836cfa"))
+                    (213000,     uint256S("0x0000d89ced1ffc0a9fbc0763d6d090bb19e2657f93c43144b359c16804778a89"))
+                    (214000,     uint256S("0x00010f939491f8393ddf82118d72bf420c3ebe01788d3cc69163865bcd848738"))
+                    (215000,     uint256S("0x00006ad713ab44526e84e11d0400e5619c2415773cf5068f4946d52bf9633f10"))
+                    (216000,     uint256S("0x00008410e6c8ecde65179424ec6443ec1b2215d2403d8b6f779da51136ec02a1"))
+                    (217000,     uint256S("0x000020ee6b9a6228bbb57a3dbfab949740801149096f7d0633066026e6792ee5"))
+                    (218000,     uint256S("0x0000d38defba9427c17c1cb43398593528af10ae6fbec1d445ce2533c4a0228d"))
+                    (219000,     uint256S("0x00001066c0c557ad46f0228c6b8ca18f17979032c55ae24ddab15394080987da"))
+                    (220000,     uint256S("0x00010f0dfb2aa26bcd90f8769709a91e0948c03b56ca24740a94f59d5822a815"))
+                    (221000,     uint256S("0x000058f2dc34a3060aa22edeb91d3a389f0732e479dc2c0d33696fe61ef1c9f0"))
+                    (222000,     uint256S("0x0000533b7f73d91cbe609c8626083dc44e8ce65ddc723729a16e9469030ba263"))
+                    (223000,     uint256S("0x0000f81efaff06d9a57c42026bc5aabe52a0ff81a37220e16c4c84904e7cab64"))
+                    (224000,     uint256S("0x000130f784b48728fa8f619617996b7e99dfb430176f9ba894a68630a851cd4f"))
+                    (225000,     uint256S("0x00003c810725d91c1c489ec513ae71f29562fbc4292719babfcc78dcb293a9e2"))
+                    (226000,     uint256S("0x0000dd323efe5d0e9adc1389e4c9eb1c4070fb38d932683032910aba746b3c2e"))
+                    (227000,     uint256S("0x000132092774885d1ce3ec989f1b199bdc178b7d406ad9b0d23d3e4e6720d3ca"))
+                    (228000,     uint256S("0x0000cf429d0c05ce9e009e501d724d8929fc40027a2f78f7e67ec7d86e91cd57"))
+                    (229000,     uint256S("0x000061b40ec34dab4fa83698ace103b6caf9271cbca2b8c7ead55fd299f23f1d"))
+                    (230000,     uint256S("0x0000ca632b73f5b1ca9d60ede2010290712fc2f2d28d08ecb31b0affc5b8284f"))
+                    (231000,     uint256S("0x000025ffb1c37889da722af7ecfe87e3897c813e4b948d30e1647d44f1a2439a"))
+                    (232000,     uint256S("0x0000147749add04281819da29a8c6d7d7e30fa9e8307738519d33605bb26772d"))
+                    (233000,     uint256S("0x0000b9ef9879f18d47d7248a8404b2f2b38490f1ea2272e2ab5d10e57e687698"))
+                    (234000,     uint256S("0x000006a82f41ac94661d4e0a3dd8d5ef790b5c7c3f68b3bbf9b2c0749ff3171d"))
+                    (235000,     uint256S("0x000088d9f88a14a5fefcba4bb61c05e43518806bbb489ea4ea3c53e48ed8262b"))
+                    (236000,     uint256S("0x000036c1032ea9f7091faa0ba289ef025926e4f012e19a65476ad061d61343dc"))
+                    (237000,     uint256S("0x000016076e6dfd0f0de47d77f975823d286c9458f0e9ce851b8a585e442d1503"))
+                    (238000,     uint256S("0x0000b228ebfb020faedd5db874ff7c20bf50f33e0ed824ce30da871ef8859a30"))
+                    (239000,     uint256S("0x000098f1ed04960ba6dada245c1d954dda785a250f1365b1d46934514b513e6e"))
+                    (240000,     uint256S("0x00004827b75431d480812d39ca8e0925e44889c18b08778b2171c78aacc800f9"))
+                    (241000,     uint256S("0x000047f75806dff17a4fbdf87a2361ebf325eb3043d3e7cee86cacabc81394d4"))
+                    (242000,     uint256S("0x000027fb57cd69593cc13f6e4ba8cc32bf5982f301c2a9e04474abac8313ced6"))
+                    (243000,     uint256S("0x0000d6fb59a655b9402dddd35f09e25085ba1a472e3c344b392d5b3ee293db81"))
+                    (244000,     uint256S("0x0000913dc99d2bc33a75deae45a155e2b8dd7953dcd87be10be4943d1b20a82f"))
+                    (245000,     uint256S("0x000041e52aed642e547ec8895d84d25203b296f871b50a1f0250ca00c5cf01ea"))
+                    (246000,     uint256S("0x00000dbbaad4e01e63b8e068a25d0210ad2c5f656f6d77da241b980fbf77932b"))
+                    (247000,     uint256S("0x00010edbb33cf3df1dc924eac96ced741f3a735394bc9fed3b8c1ad3692b3ec5"))
+                    (248000,     uint256S("0x00008e0bfb7b326a4bfc6a2995a14f357a27f5725d930a62d2d3ba80f59b2ee0"))
+                    (249000,     uint256S("0x00000cf51bb1334a730b924430908700a6f6a995bd9dd252d77b7f94a014c8a8"))
+                    (250000,     uint256S("0x000090c5798405d73f400657dcc5685172c6b2608809a9ec2e82297716e5f5cd"))
+                    (251000,     uint256S("0x000082d84ca93a2211bb870b3dc2865092fba3b772acbe934cb0a6ff99338762"))
+                    (252000,     uint256S("0x000090f2de1badb88177db6c3682f0f223196f51a3e054fe6b06caa5d5e914e3"))
+                    (253000,     uint256S("0x0000e0f97c745975bbe5050af8fe92637a7d0cd458cd1706221d34af719f995c"))
+                    (254000,     uint256S("0x0000b8eb6c3ec95367882780cba0369222a9acbdbd626bbdc2efa5e9806309ee"))
+                    (255000,     uint256S("0x00003f05f5e1dbdc2038158fe47ec02994e8cc643a710a513f8f489dd58f61e8"))
+                    (256000,     uint256S("0x0000d31f04b719ad5681f7e1b517daccd9694fbc9409ccd286f558455982d261"))
+                    (257000,     uint256S("0x0000ed07ac5882e040bb9de0f4ad4d4527ca5c73c4f1a88eb53dc0651ecbd1b4"))
+                    (258000,     uint256S("0x000097e6df4db5049fcff2e691c02570d82c7dbd168189c06f31dd94949ba8b1"))
+                    (259000,     uint256S("0x0000e2e8b741d28d9a097229d6e5a2ba1732a82fa2ddcfb41f20eebd94c76c32"))
+                    (260000,     uint256S("0x0000263c2baec9d5575580a30787d4893c1517b64ff7294e41f2efb16d21ef85"))
+                    (261000,     uint256S("0x00008b142681d8cfc53df1ea806f828f9bdf64789eddd8ee3d031bb8ef8acba8"))
+                    (262000,     uint256S("0x0000d2482da09b9d9f76fea70205c1de1029074f2b352ce4b44e86188139daef"))
+                    (263000,     uint256S("0x00007ab5c28f261713ec133b8543393d556c1a259ca05968bd3075792aab3ca8"))
+                    (264000,     uint256S("0x0000a75e0af3d8f54950cdbe04a0d083eab58c4aa5c83151883f1e4ed3b81364"))
+                    (265000,     uint256S("0x0000189eb94df3a9cbc293fb896cdd2c0a11a96c6312ebc48dabcc87c1ce77d5"))
+                    (266000,     uint256S("0x00006843e067df56f2eda15d3d2f2b0a3ce1f9ccca76267b43b355939538d94f"))
+                    (267000,     uint256S("0x000061e5f1d6bec772831bfcdf02331a6cb8824a2cca249ffa49737d19782447"))
+                    (268000,     uint256S("0x00007f909a3f437fbef9702678e510ab70af79371ea7810af0ae12fc5e9e014b"))
+                    (269000,     uint256S("0x00007de818cb26675fd9edef889f228985951c8654354ff50671f672bc868815"))
+                    (270000,     uint256S("0x000027590b1638a77fbcf91aa46bb6fe044bf24a63a79ad6cc74b46d2318368c"))
+                    (271000,     uint256S("0x000066e889f46e219dcf0b4406ad481e8fc400bc65bc4de757f8a2cc946ce9cd"))
+                    (272000,     uint256S("0x0000380a032fc737f0d643ad61ba707f4c6fe939a2b430b10fa581f5a0679100"))
+                    (273000,     uint256S("0x0000126824caa6aae226452aab57a114ffb6afbf8cf261963a3961318a28b419"))
+                    (274000,     uint256S("0x00005c4c0b084a1d192dfe12783aa91c778f1e709457e73cf76f5889cc26bb78"))
+                    (275000,     uint256S("0x00007dc532c6b377c64462a8b8c16b3eff0096fbd9c6b4006c752ce7d653989e"))
+                    (276000,     uint256S("0x000010f0388da6d99966cf52ea61c27d687ebe07e8235725df251ad15ead0dee"))
+                    (277000,     uint256S("0x00003e8d6d6063171e835af9113f880af2a5907712d3c0e96350d3851961856c"))
+                    (278000,     uint256S("0x000037ba4dbfc93957ec601b00835a98c16ad2ed58c26c61ce4b9c2a3d333ec2"))
+                    (279000,     uint256S("0x00006717a9b460b220defcd60216be89ee2c433a2d888bfcab850ad5f209d94c"))
+                    (280000,     uint256S("0x000041384c4c769143b1501c7c6f892a4ae5e295ca471499e08c8299f5162099"))
+                    (281000,     uint256S("0x00000b03c4c5ebafada3fa92aee6703ddaefaab554f48bb204e358ac0aa97add"))
+                    (282000,     uint256S("0x00006be32af84c330c5d7d2d97684f1e3fac9e1f298784cb15b35df6bc606f8a"))
+                    (283000,     uint256S("0x00000dc131bd64e0911950eccc6ce708ac27bd7388da64e19d4cf23ef888b5c7"))
+                    (284000,     uint256S("0x000075deef6c427d641f480805c5ddcf260481983924be5f6a22af7a934ddaf0"))
+                    (285000,     uint256S("0x00007a019cb2e868b90a7c30debd7de1bfb5440e06c5bd8187f921358c7ae781"))
+                    (286000,     uint256S("0x00001095ccb8ef1028bf4ef8df40467441167280b6a7a15384ba60708ca4ed29"))
+                    (287000,     uint256S("0x000085d7c734a13bebb8057beff8deec794a930bd6300af1becd7de50d425fa4"))
+                    (288000,     uint256S("0x00001d8395c53c0fc68e536df49fe942caa67f6d8a3f91cdcc018d15b3fe0593"))
+                    (289000,     uint256S("0x000050cee8c1581b2d8214d43f9a8c888bdb390b91352fd5347b48df92828b8b"))
+                    (290000,     uint256S("0x00004240e011ef34f0b6015698b4baa2728b2885a69284afab0424fc6b09877d"))
+                    (291000,     uint256S("0x00007c90a0da5bd891f8de0a7a09d1b8af3831143926d02e90d29d9d1934b5e6"))
+                    (292000,     uint256S("0x000015965fa7e60705a11e595a18875ed065d8b11d8030880e59a5d474e458f0"))
+                    (293000,     uint256S("0x00008981da5387cdfb537ec9d4eb8e8bc81bf5f18938eaf04889acf011c96749"))
+                    (294000,     uint256S("0x00003810c0f915b3fc12207edc99f7b9226f5572f491e7349e79b228c8e7469a"))
+                    (295000,     uint256S("0x000087f128604abe37b8fefd2f098b0e0984e6e7a65e2151889a302a68c06eca"))
+                    (296000,     uint256S("0x000062a42664d4c4e88bbdbd991e7fee35f779c126dd27386e5225d2237dc2d7"))
+                    (297000,     uint256S("0x00001c42f5f24b38f202527e3c2cfec3f5621ad87e75253b5d431452d786d4c4"))
+                    (298000,     uint256S("0x0000198517575016a98ee8b54deb7232c2312f017d60959280060ea3cf92e4f2"))
+                    (299000,     uint256S("0x00003a9031fb5b7e9a318c08588f63e52a6c91845b444e515bfde4c9b88bffe0"))
+                    (300000,     uint256S("0x00000c72234e026b3ac4be4a972889fe48810cb27d551058b77d4c5e9b32575c"))
+                    (301000,     uint256S("0x000099dff2afc7600c8b724dfc3202d0d29d38ebef21ffc02f4e2f2a66ccea99"))
+                    (302000,     uint256S("0x000085a79dd00da9a21cff9b4266a8fe5c2e90b5ea53ec1c7792295192a2e37e"))
+                    (303000,     uint256S("0x00005798b40b3eb295eeb9be6af8ca5007784beda82d04a4a8b9c3a2ac0b1096"))
+                    (304000,     uint256S("0x00004eedbf20eec4f279484eb5c13c266d463475ad2fdbb7447bf0a8acb7ac6c"))
+                    (305000,     uint256S("0x000029cab3bf30d2b12ef99eb43ed67bf6f81399938cde4f061dcf1d3a3b8282"))
+                    (306000,     uint256S("0x000030648c81f681bc962e698a27f587da62182e555579910c456f723109b42f"))
+                    (307000,     uint256S("0x0000085e26e0618a933a35267273dbeec35ef76f83d7543443cd55a2ca0e233c"))
+                    (308000,     uint256S("0x0000239ea91faaf5425f65fc585e7fac6dc518869a1a7091450f90ee8bdb2fd1"))
+                    (309000,     uint256S("0x00001b62fdf4af7be68cd70b1f982d29260dd1e667ef349314a4bddd73d55496"))
+                    (310000,     uint256S("0x0000765eb51eaa30265211672e8311dd40e265ad4142f4a03efd2f4089d9e186"))
+                    (311000,     uint256S("0x0000140c77cdf8f9d4b289aebc0310305693f970ec409f2b828c3ed513f3e58e"))
+                    (312000,     uint256S("0x00003f6e2f0e82c242e5b0a7e126ad210e53fb0dfbe794ff2d7e1cdd3873e818"))
+                    (313000,     uint256S("0x00002e678cd8a3a18a1cdc5c957b6c0c880acc21b801c68cc4d7b37110a83f22"))
+                    (314000,     uint256S("0x0000198bbbeec4927abfc60f2becfb96a5b0846962d65b32de3f9243bdf39af8"))
+                    (315000,     uint256S("0x00006c90b93d54587dfd63105e063f6ddf43cff500aa9968622df5c93a5b0798"))
+                    (316000,     uint256S("0x00004c21c397bf276a5cd62d960e308fcb098ec45bd60a4f1bf023b6edf2e6ad"))
+                    (317000,     uint256S("0x000036b7f6b9e2dea52a6067a94f2e2704bc1824c8e11bd300a841c46e7dd2c2"))
+                    (318000,     uint256S("0x000025029ef96a105a50a7030fb0d61edeceea25e4effb02b3ce8eb4c6205782"))
+                    (319000,     uint256S("0x00003537409e025a8075526fa097882f919ee169606a9368d8c3db2d33119e14"))
+                    (320000,     uint256S("0x000023b752e4c077f231d05026220244ca10a603324035b885e1b0dd6443c148"))
+                    (321000,     uint256S("0x000003411062d7ec945c786237575766c5ce2e48c4f94ca04f28b1404ba86097"))
+                    (322000,     uint256S("0x000022447ebbb48e06508a70746f87b2e55f026b8ae3052a168f29848d3e2aa7"))
+                    (323000,     uint256S("0x000057eac2e6c611398b43e8a72b83f5863b104fa66120e707df6e3e6fa1ba8e"))
+                    (324000,     uint256S("0x00006fa40d2be13a2ba910156769754eab5d55059729597a02194e5e0f84b336"))
+                    (325000,     uint256S("0x000007fcd4dab7c2cfcfea47ce88932d3ced21fa9264c1c8ed9cbf3fee08635e"))
+                    (326000,     uint256S("0x000017fdd022300e952d9274c63cffd8c791dcaa4d82e5d1c9615464df19ae13"))
+                    (327000,     uint256S("0x00006739a0fc2ad8788ef615aa26d6a9c7c6d6adf9a9e84f7ae68379eca2a0b3"))
+                    (328000,     uint256S("0x0000777de98944635470c99ec1652aa2c15ce3ff4b19de17eed5373d2474a6ab"))
+                    (329000,     uint256S("0x000042206ddb76bd7efdb14b694543b685771c6c341089f5bd1dbfa04d6eace2"))
+                    (330000,     uint256S("0x000069d6c21607c368128d4586255f315c55380759a766f961acc35a2e9cb166"))
+                    (331000,     uint256S("0x00005b19671f21015db7011c9702a420bab766d8bb7cf25b8525429eeff36b45"))
+                    (332000,     uint256S("0x00002d62d1f4d13ec708f65c04937b86cf86a36f68caec269f598e8835ca362f"))
+                    (333000,     uint256S("0x000013ef2283eae4c9631b4bbbe80b4fb06b663e25a569336326d7897d80a9f8"))
+                    (334000,     uint256S("0x000018b4c8d94267953a1df06439a1393c903255a58c9152593eb2d369d87399"))
+                    (335000,     uint256S("0x000022628e5db36faec4fe5f107deab56c47c61bb29a51177ecd6f86939d83c1"))
+                    (336000,     uint256S("0x00000f22f49242eb151276aa5fc84debb67bc632197c448dd23a501923f6cdc9"))
+                    (337000,     uint256S("0x00004aea6cad4849f27af16c298a990e242b77e249eff52fc9c955c121d5ea62"))
+                    (338000,     uint256S("0x000064b79a8fd98e2c57184d6ac67daad8278419aee044bec13c7d8de0baebba"))
+                    (339000,     uint256S("0x00007ed65e7fe77d691f91d1ed0fbc40413f277770c8a5aa389505b2a179f428"))
+                    (340000,     uint256S("0x00002d001410cef77057d66b49c1949ca1367e11297a595b13f17ff1676e55e9"))
+                    (341000,     uint256S("0x0000544668ada85a8429537011fa53be0a2c2801c6c022289b8b056ee54e96ef"))
+                    (342000,     uint256S("0x0000311ec160ae645fdbffa2eccbdd4212d6c7a5de7e78786d37e9341d531f75"))
+                    (343000,     uint256S("0x000010a8f4eefa8040add659396d269e245441439e33154a3b7324ba8884a6fa"))
+                    (344000,     uint256S("0x0000500a9df05634fe8987d437cd3ccb502fc36c00fdc73195bbce7d63d1a7a9"))
+                    (345000,     uint256S("0x000002a979e67ec52d92b87c4637f166c694378a9a57e3f8103c7d8a084f551a"))
+                    (346000,     uint256S("0x000026662841a071a8c0cc28bd560b42af3b739db3d494dc9bf2754bba021da5"))
+                    (347000,     uint256S("0x000031d4a32cf5e1c4f1b7d7e3556a2ce8de88ad3f5307f5b20cd7e40a2d1401"))
+                    (348000,     uint256S("0x00000f91efbd01c0cd21b1ab0e0daf2d014a7e6bab3fda7ef480ab35c80a2421"))
+                    (349000,     uint256S("0x0000460718b2aee973f80306a37506f9cbf40123fd1205c26c33b0d9749d524b"))
+                    (350000,     uint256S("0x00005953abe841392b72e8fab12e3cbceb18c128f73e1aa4406defd18543fe4c"))
+                    (351000,     uint256S("0x000018647cfc45a1524168193e67e6af22e8677ba3428dde5f6a2f76c199532d"))
+                    (352000,     uint256S("0x00004d0d3fc72f9d7f9a6712c098eb6cef0a7756886011f036736de200fbe5c9"))
+                    (353000,     uint256S("0x00007948b8f6bb2433088cffb4bb18ca1d03aad3068a7ea923475f1aa108fd20"))
+                    (354000,     uint256S("0x00000a0072325a23f9afcaff49a8c3bcb04f1fcb01612de33bcb9f0f20ebb356"))
+                    (355000,     uint256S("0x00003e0133ccefae6723c9f14bfd290a7aaf60c2bc962c293fb58b5957ed1a2e"))
+                    (356000,     uint256S("0x000005b41a41a8ec5c60cad85a03d9fa5025b5d9a088a6bbc2ebd1d8e858189e"))
+                    (357000,     uint256S("0x000021655f02625c28257183e5c4639841b11661cf40f00fc5ac4bcfcf1eb072"))
+                    (358000,     uint256S("0x00007c3fe61dca2d5c52bd5e9090c91812bab9c6a7407e32ed0a930b421f5b80"))
+                    (359000,     uint256S("0x000063f8390cad7ad17cbd18983b923e18a1469d5730dec7a62e12914c66df9c"))
+                    (360000,     uint256S("0x00000f11a3a78c71d8a7c722cfb52f51006b3656b707cf94c0b08a80c4fd4dc9"))
+                    (361000,     uint256S("0x000008e76b1c141b783936c946af3f121d5b96fb8766d83c58ea7f7602c78386"))
+                    (362000,     uint256S("0x00000c92d4b3163c33c0efa3feaf6f4c170f9d6288d2435a09435eac87d04e09"))
+                    (363000,     uint256S("0x0000567379ab1430696266da7ee6dd1e7ba0eb91bba09c85f558c181e01625e5"))
+                    (364000,     uint256S("0x00000712954e172eef571e8297ea1843aba0a762b31b5b2b40ca2027e7c0b1ec"))
+                    (365000,     uint256S("0x0000627358770bbc0bf614acb3d02d996f220562f083d08c75e71aa2e83a7870"))
+                    (366000,     uint256S("0x0000404c17107474c2a0704c9920ee16e502c8119581f4707e0959af3004746a"))
+                    (367000,     uint256S("0x00006c5d54ad2b5279842e8ee726359064c72a034c5c3d5f261413c2cc6a4e6f"))
+                    (368000,     uint256S("0x00000df9f5d119afd39c0654010f1ff492f8e04dc1dbe1cc0d3ad5767601c91b"))
+                    (369000,     uint256S("0x00004e47d205ac774a1f6d7d8bcc29d6eba6f11005b75aee6dedca1e46a1c1db"))
+                    (370000,     uint256S("0x0000810057e4efa124db97d9433372af35b93ae61ea4b620f7ac3ac26658a5aa"))
+                    (371000,     uint256S("0x00007e49d0ae73df2647b33550aad63d79c05e40b08fc1c25cb9450ad2b5e8f3"))
+                    (372000,     uint256S("0x0000076bfad90f3f5befd763f0abdfd05077821099e0c33bc3947ed853d0b928"))
+                    (373000,     uint256S("0x00000d03d70c31a5ae2d32b66a3528981c88d361cc165512a3d9278ebace0589"))
+                    (374000,     uint256S("0x00003e477b6dd1ffc2218862bc18b5a651c82122cdcec0c455613d1891e9a727"))
+                    (375000,     uint256S("0x000012ad562f8b65a93cb2eb5f708d55e4c3ac689d2020843c55b34099755233"))
+                    (376000,     uint256S("0x0000556b17a0197dbaba33c7f58fee2cc9219b6918d925a4146fa7fd5de0e94b"))
+                    (377000,     uint256S("0x00005f1ac71e07fcc4f44fdfef693983a872be58f5b1bc04d13873408a54f2e2"))
+                    (378000,     uint256S("0x000014e65f4e30b3097d2ebb33c11ada6abaf81e8ac3ffc2e0b6d4756b59822a"))
+                    (379000,     uint256S("0x000021418aa5de171ac72097abad42b7f1af1a2f7e19b4c98c7174d5164fa5bc"))
+                    (380000,     uint256S("0x000046b214d061a9c237e42bf42493f9792cf80b95f89ef10f432cacee23eba6"))
+                    (381000,     uint256S("0x000068f06f5bf5b288e78d694775cb76cf1ed473f95da29790e4b60133d6bb87"))
+                    (382000,     uint256S("0x000008c5632f8e3f8e61aebd686b624c7ad644227639d320c3ad286f71d4e14d"))
+                    (383000,     uint256S("0x00003b7fffa7e988b90e05d94d24153b0a22e01d9ee0c56e04e9263c88c558ee"))
+                    (384000,     uint256S("0x0000083022ca686c81f5f403743dba37334a0e96f96d3c8bed7353a1bd11e58b"))
+                    (385000,     uint256S("0x0000485dc4369a16c2c8bde7577ce99ffd0a15a1d21cdf61c01f0bee17b36b2a"))
+                    (386000,     uint256S("0x00006da0099b6f9edb40dab855231677bf4f97b0e7643fccad05cd97a8b76397"))
+                    (387000,     uint256S("0x000063ff38ec555dc089900fe0ff5648488421918db713941d6c24cfebad37fe"))
+                    (388000,     uint256S("0x000069ca27290d71648678a0c5ebd379a17ffc895fea7b23837093a337563060"))
+                    (389000,     uint256S("0x00004a1e13ef7557c9dfe0c7daf3e7483e7d1420afff64a5325af7d5bfe49994"))
+                    (390000,     uint256S("0x00001dce3a9cdd42f97d3268d29bdad179375f61f7d4e729919450996917c583"))
+                    (391000,     uint256S("0x0000071173926b7f9492e35cf48185c2cb57ffcaff2149dcef5c40148a55255d"))
+                    (392000,     uint256S("0x00007c3336097b98f2fbc46dcd4f981e73ddb93c8096015282eba490b773cda4"))
+                    (393000,     uint256S("0x00000738869c9b8cf66aaa075ebefc5209c90a0f225b405e1850b0b00343bc2e"))
+                    (394000,     uint256S("0x0000537c3d2b6794fc5c2636a3311e1cdb34c019ae2dc09778d0c500e1593f2f"))
+                    (395000,     uint256S("0x00000dad4673f1db54a434d106a69af55f494ac29a428ff37f4e4aa3b734a37d"))
+                    (396000,     uint256S("0x0000514b509a25edc24df6d94e24e2aac5727c18d361fdd7e64356f2233016b2"))
+                    (397000,     uint256S("0x00000eaaf35e4358bee2a8c5981683b15214d7ecc03701438f94f5306d10c6c3"))
+                    (398000,     uint256S("0x00007cb707f7132454c53ba8410dbb588c3b23e7d731f824d58da21f4ac62330"))
+                    (399000,     uint256S("0x00000cc6edba6cf9dd44204502309c781a1f769e019e42306c785dfd2d3614eb"))
+                    (400000,     uint256S("0x000023fc6e679339fa72280568217dee1ea0c26790c13f80d0092f9b12ed5f38"))
+                    (401000,     uint256S("0x00004ee2b9c7df597e26a4ee85b56c0842380adf5d15b9f6667a132f7cb0b07c"))
+                    (402000,     uint256S("0x000073b711054a260c45b4ad63796949d2a00a0baca00e1a68ed16fc98f45d70"))
+                    (403000,     uint256S("0x000070b43d9d52a1f896a13bfdfb445fcc3b1374b7ef123b0cce1488f551a954"))
+                    (404000,     uint256S("0x00007864734f9e3f3596d9d92df853d3a9b1172ff747fe5983e09028114404c3"))
+                    (405000,     uint256S("0x000075ff54f6af74e69cb36dfd7634dace0c68e00d309da017f81ea5dcc9480d"))
+                    (406000,     uint256S("0x00008b908deffb33856ccd1ef6afa73cf8bd01e8c3b5be502829dd64157e3f7e"))
+                    (407000,     uint256S("0x000023d28f6b13c134285247c6d8191f16a94463ccd84a506c99ba52706b67e6"))
+                    (408000,     uint256S("0x0000723a9c35577d2e56749861ad4e9d3c61b1c650e0c7c832cb1d60346fb46c"))
+                    (409000,     uint256S("0x000021a04d41834edb1ebf0c3c09488fb1e3da4c30acfda07ef154de955dbfc0"))
+                    (410000,     uint256S("0x00007b63162192a0b9c1015a227df9fe264591b5842aab61a637c06768a5e3d7"))
+                    (411000,     uint256S("0x0000064165fbcae2b8c44549630ec47c9504c77ddd0aaea91e846539ce023c6d"))
+                    (412000,     uint256S("0x000048d4879eb955e516485f822f2f52fa078f02396fcdbd1e0fc0698a90d577"))
+                    (413000,     uint256S("0x00006df51ae354366835450d019ea8a7a59a34060dec74de630bdf8004bbbd18"))
+                    (414000,     uint256S("0x0000113f9fa68a6a1acc32aeab61e8ca15e1f53e9f43b9e77bca85fecc7871d8"))
+                    (415000,     uint256S("0x000003ec7bf286218a52ceea9a5b8ec460a5a77211679c2b8d1d1e4ff96c03fe"))
+                    (416000,     uint256S("0x00000c4a34784e10158b231baa9c35b6aca1cb1d967f65bdeed7480f55df869d"))
+                    (417000,     uint256S("0x00004462829936ef1967f6604d00c0e034588642dacc1ec827ec3b4468202ab0"))
+                    (418000,     uint256S("0x00005debf20584e6e0adb8c05a73bf4b30484451964d39536f50bb02b426b0b1"))
+                    (419000,     uint256S("0x00006357b1afbb6aebcfc778c06ed1fc51fbb51a7fc9b882c4c9bb4a35e0b4ed"))
+                    (420000,     uint256S("0x000040207b5dc0f5e2509b1216b549672c58d68bac8224f67492aa803b2f2570"))
+                    (421000,     uint256S("0x000042124fbfa2ba3db57f39bfd4f5986969c5c4faf8b1c06cf470a5ea001788"))
+                    (422000,     uint256S("0x00003c97f3bdafac16b245ea1f3b941c52388be5bec9c087186ac17088d5cbf5"))
+                    (423000,     uint256S("0x00005068310436b42ace3d987e8a10eb858b4a23321dfeeefaef22e9446fa2b0"))
+                    (424000,     uint256S("0x00005ef6829528a3504565070d82e425614426ab25b45bca04aa4af3d7e0e29c"))
+                    (425000,     uint256S("0x000024123c6a896dfb002e50b4574037d07bb94e0a0e9544e67f8a2e090b6b89"))
+                    (426000,     uint256S("0x00004f641099594d32e1880080931343420e8597be3939a4f6628969d4c94a4d"))
+                    (427000,     uint256S("0x000078d2859474d6b72acaa6060ced2386028e457743bad4cd9b0ced3f8ab154"))
+                    (428000,     uint256S("0x000087e3b407861303f6b32015910f4a3dd0f1f78a4e53f178ca442e9275c317"))
+                    (429000,     uint256S("0x000060b5c76252c68f358202b6f6c421d5ca9c705dd28240882258df8a809174"))
+                    (430000,     uint256S("0x0000305e76e05f96396d96187e6d35e900a4d735aeee6f105168eb45846d7055"))
+                    (431000,     uint256S("0x00002181db7f434ad47bfc295f8ebf8caa382f13829ff70b06263648e0e033ad"))
+                    (432000,     uint256S("0x00003e3f8d3848689893840e239619e875db02745d68709a533e30fef16fe9b1"))
+                    (433000,     uint256S("0x00007ec0e6150fdeee913a18f5c8f3d7099bc744a218dc6a01c63580aa9c8eb1"))
+                    (434000,     uint256S("0x0000415b347418526dbbce15098f2d8d1b5a1dd0446151efcfdd3318d5861351"))
+                    (435000,     uint256S("0x0000663b475c89a1ead8cc41c1ed10c8fcdbf417d007a6f0b95580a1165eaa1a"))
+                    (436000,     uint256S("0x00001783f2a7362a81e0b49cfdeb7dbb032e6e9ab4f66b3cefb4e52f1c5dfb34"))
+                    (437000,     uint256S("0x00008486eaa2a91c1ef5c530065431dbbb0c4240dea7a2101ab0582484003280"))
+                    (438000,     uint256S("0x00004fd678f5f493ea4e9ec5b54dd66749350fcd325c5ec677c154bcbca88799"))
+                    (439000,     uint256S("0x00009244e5e34e05cfcf1bbf619c8a8b43ceb538fabfa7843be9796a295e49e8"))
+                    (440000,     uint256S("0x000036b5b2b13908454ede21c5826af6331b728a66da7fc67bfedca910ff9b80"))
+                    (441000,     uint256S("0x000034367b426ed559bb7d0b1046eec735a850c53fce26f8b0716198ff90051e"))
+                    (442000,     uint256S("0x000059583a267d919d5bc4c65abf8c304150e45a336b9f34bb35ddaf0bcb1787"))
+                    (443000,     uint256S("0x00004f414772200bfaf67651fbc4cc103367a5108a35fe026850a4bfd92d38ff"))
+                    (444000,     uint256S("0x00001b9bc79d27709c34a96a5dbd6a259fa1495afdf8fd05c23a2d659602620c"))
+                    (445000,     uint256S("0x000061e49c4d2d995a43a2d2b491a023444b70aba5150ee4d2789cfca6018710"))
+                    (446000,     uint256S("0x000051f2bc3eb24aa77017476494528e0096a0a1cb1e29b4318ce9b3410c6751"))
+                    (447000,     uint256S("0x00002979121255c18f58c5ec1a4267104585577b91e2e61682b44d65930400f5"))
+                    (448000,     uint256S("0x00001122c7a9f21b96941e6e074122ce55cb412d659ffbfad8a0bebcbd487533"))
+                    (449000,     uint256S("0x00005ed4ab8507e94702e24ce16b257e8eac754be1eb3e743b430bdbe3e2eb14"))
+                    (450000,     uint256S("0x00001579df12ce8d38b8f4416f221964af6aa54bd065201c578bee6e03596463"))
+                    (451000,     uint256S("0x000057eae48d40b8b59a16f65fa4b5902b27dbe0bb5470cd27214f4045172d87"))
+                    (452000,     uint256S("0x00006e7bbad31584a17b7bae4b7555a4807ce276cd5046a309d79f0a402cdbd9"))
+                    (453000,     uint256S("0x0000011e661360329ac1ba58e11f2358731abd884d1c590525d074195bfc8ddd"))
+                    (454000,     uint256S("0x000065acdfbb8d1e0d66b358f81acd99711adedb85f37fd522b8b515184a073c"))
+                    (455000,     uint256S("0x000026888730aacaf408c7b6cdd5a4ebce04f4c2aea22061f5ee832a65c52b24"))
+                    (456000,     uint256S("0x0000602cca1d31d8a750c84cda243b6d454d4d93bcc2241cf0ae6982a4716755"))
+                    (457000,     uint256S("0x00002d7fd2ac55de783d6f69270fd9e499789185e98eca4561bcfb13be663cee"))
+                    (458000,     uint256S("0x000015971c8c8c0d2b2ba9b9c0dd5c97091b77e3bd747cd8f5a1396d7cbc39d0"))
+                    (459000,     uint256S("0x00008473ea08a574ab72f3246462ca97fed87478c6e5fb39bb9b340f6c8b0f44"))
+                    (460000,     uint256S("0x00006487396edc5cb9bf6f5cd62491d1d5a47e89257ac0286cbcc8f428239fb7"))
+                    (461000,     uint256S("0x00004579751a959bf33a7418c872ee533c11dd0db764bdbf800317fcca50db74"))
+                    (462000,     uint256S("0x00005e57d635a75aae751e87aa9081218babed5522861be57ca55ea5d91e5cc3"))
+                    (463000,     uint256S("0x00000fb2816e0c45b5414b72aa67a918c1ffc6a5e114d4f4aa2c1863f9d7ea7a"))
+                    (464000,     uint256S("0x00003c2985800d71f2875169d86d911bbf3ede85eaec083869bcb817d5930407"))
+                    (465000,     uint256S("0x000037d41b8dcc82d16da8907512e4c0dd4d98e5f8e1985f6c418d62fe38bf20"))
+                    (466000,     uint256S("0x000034e51cc154129c394b6130d3711bf930c47a0943c0e08598353565781e8e"))
+                    (467000,     uint256S("0x00004c2bd9c0a4414e9c689b21a8266dcd0ea9f0363559940c77f53dac76a746"))
+                    (468000,     uint256S("0x0000097d658883238e26170d0244759a6a0fb53204e392bd5607bff329e52580"))
+                    (469000,     uint256S("0x000068c832e7335fa8b095693ede2161463e250a6857171efb34e8b2c858f0cc"))
+                    (470000,     uint256S("0x000016f55342090f2f7dd1013c1780daea3e18331b9e481e44cc969e42267c9a"))
+                    (471000,     uint256S("0x00002544263ac1d071b15575a1be34f3e220e97b631bbd0a37ca2211da3be579"))
+                    (472000,     uint256S("0x000082479a6d345f52f2f6a3a7f8b3e1bde3e31bdf6971ae7e17a4e9ceb9f3d8"))
+                    (473000,     uint256S("0x00006af93834d09ba9e22c0e9bcf041df511fa73adc7c3b90b20930c14dc3afc"))
+                    (474000,     uint256S("0x000009f5395a0e10bd3467d49468f22a17b96cc56f133742b4b94f81d055a1ed"))
+                    (475000,     uint256S("0x00000732dfcbe6c20963da08712f407c0137c686c2c5b8199be7ab93533ca75e"))
+                    (476000,     uint256S("0x0000212ee23e893f853ef49641d748435b3a783c12eccfaa9d113ed1039a59aa"))
+                    (477000,     uint256S("0x00002eb7f121312d1702a95d23e6058d305bc2fcec6b665918d1f61ccdce3d8a"))
+                    (478000,     uint256S("0x00007c3f92685d1ab3a31d4462286825e1edf247b74f0f2acf203cfda160b4b6"))
+                    (479000,     uint256S("0x0000387969e04687fa879ecc4b7ef42e94d7702b2adc5c895b91036f2b2b32a5"))
+                    (480000,     uint256S("0x00004fcf6a8c13044beef7a176c1b872bbec53cc00aee74a4cbc9f7cb332ad29"))
+                    (481000,     uint256S("0x000071ff0caf576084563d6bc15fe7887b261a22cd7f2540a047486dc97cd961"))
+                    (482000,     uint256S("0x00000d18b5deb42f4a383a510d5ce92e4ffe84cf12556adb09cfc381eae9343a"))
+                    (483000,     uint256S("0x00003045108fd460198ab5db9154df288f796e4714d78bfc030bf32a0d72ece4"))
+                    (484000,     uint256S("0x000077ab6ef56dc32d8d78340e0f69e9666914ce0299c16d80c9ed44b95cc74c"))
+                    (485000,     uint256S("0x00005641dd3b8af4af4328e7240b2f614d4f9bc02d941f1cb753fd9b9e648ac3"))
+                    (486000,     uint256S("0x000045d840594db850fdf19c03b29b2587b225f7c17009b6bc92c3a95d913714"))
+                    (487000,     uint256S("0x0000428e6bef96b2cfa2a512d10ff22f459e1c81dfd833935bd2bec9a9401c70"))
+                    (488000,     uint256S("0x00004b7a10c67d0bd09058183babec02861c0722b09b75038d3779a586bcee48"))
+                    (489000,     uint256S("0x000023557e9510f58a398eeaf0c36753b93ade77ce885f8736011f5eba399340"))
+                    (490000,     uint256S("0x000021e70faa40c6b1cd9ed3f91b8ad43e2570a00e34c54c5ed74218ac33bf72"))
+                    (491000,     uint256S("0x00002edd58e2126702485fddda9eb55d1d39880c44de8d8c0efdcdecdae2722c"))
+                    (492000,     uint256S("0x00004f00c0831ebd6675da2aa83a3352e79affee2786a26dab96cda9336b7ccc"))
+                    (493000,     uint256S("0x000064438694b83dc959b20b82cd5da3f4622186404753b97340450be0a15755"))
+                    (494000,     uint256S("0x00003607262aef0da4f84721222cfb5cbb915db323ec95e1b4e70bf3ce860c6b"))
+                    (495000,     uint256S("0x000024c603dbf750c01c2975ab60624bfe5ed2e44532649917d9645ae6209ebf"))
+                    (496000,     uint256S("0x0000191661868f098c37178cebe1c4eea37f311eaeb82e5148f1452b26d1fbca"))
+                    (497000,     uint256S("0x000029b3502c67a39247b646f286d925af7d0501f994c4367d8769dadaa9ab1b"))
+                    (498000,     uint256S("0x00003e7be1463cf709a8a1fc6b431c442de0f5e972b8b2444fcb2d275287d36c"))
+                    (499000,     uint256S("0x00000d00e2075b9de577c9f2b21927ea21f4bc6719734888073e039a43e3f30c"))
+                    (500000,     uint256S("0x000038889c413584ecab16aaf0ae8f050fec136484416084187a2fa27ed1efc4"))
+                    (501000,     uint256S("0x00003e0981fdee677dbfdffbf5910ab8ccab4d91e2e3f10594668cad35e0fe1b"))
+                    (502000,     uint256S("0x00000e08e2495364b7cdd48cd2999e568e92f4ca9b27343af4240f9adc194f9d"))
+                    (503000,     uint256S("0x000014996d031f6c0b0d3e0268d22c75ee9bed7e9f845f81b8df5dd38b195995"))
+                    (504000,     uint256S("0x0000041a7d55d6e9344faff6af6a60608a4572f3c12adb79a326606e5b168cd2"))
+                    (505000,     uint256S("0x00002df16f23a38f3bf6e3e42f5f14ff44bb357a975c8eb43d4985f16e4a7628"))
+                    (506000,     uint256S("0x000042c9adeb835a1105e772a9fc637d156cc8eff5d71a78243dbf3fe0ab096f"))
+                    (507000,     uint256S("0x000001c27a7bf812eb8ba21e6ce59591b2eaaf50121e5c98fd740629d00a4e2b"))
+                    (508000,     uint256S("0x00000716bb09e7513f50d5ea46d15324d892c305a11267306c009c720f51d3bb"))
+                    (509000,     uint256S("0x00007358b4d32fac5362839bf3bebdd938905766ef3e853d00ebf8557a724239"))
+                    (510000,     uint256S("0x000045c957443966535795a08bc5feffee0f0c59b55d7ba727593dbc459a1c34"))
+                    (511000,     uint256S("0x00001d9b8898a1a26bec928ded3b3650b6e0b6cf6589f95072fbff5586057716"))
+                    (512000,     uint256S("0x00006c49e4544ce19a6b3e4a4e82e05fbc3ef1ce9d3dee203cf09f047ec92d30"))
+                    ,(int64_t)  1686842247, // time of last checkpointed block
+                    (int64_t) 523914,      // total txs
+                    (double)  1454        // txs in the last day before block 512445
+                    };
        } else {
+            // all other HSC's with no checkpoints
            checkpointData = //(Checkpoints::CCheckpointData)
                   {
                            boost::assign::map_list_of
--- a/src/hush_gateway.h
+++ b/src/hush_gateway.h
@ -18,40 +18,9 @@
 // paxdeposit equivalent in reverse makes opreturn and HUSH does the same in reverse
 #include "hush_defs.h"

-/*#include "secp256k1/include/secp256k1.h"
-#include "secp256k1/include/secp256k1_schnorrsig.h"
-#include "secp256k1/include/secp256k1_musig.h"
-int32_t dummy_linker_tricker()
-{
-    secp256k1_context *ctx = 0; std::vector<uint8_t> musig64; CPubKey pk; secp256k1_schnorrsig musig; secp256k1_pubkey combined_pk;
-    if ( secp256k1_schnorrsig_parse((const secp256k1_context *)ctx,&musig,(const uint8_t *)&musig64[0]) > 0 && secp256k1_ec_pubkey_parse(ctx,&combined_pk,pk.begin(),33) > 0 )
-        return(1);
-}*/

 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base)
 {
-    int32_t baseid; struct hush_state *sp; int64_t netliability,maxallowed,maxval;
-    *available = *deposited = *issued = *withdrawn = *approved = *redeemed = 0;
-    if ( (baseid= hush_baseid(base)) >= 0 )
-    {
-        if ( (sp= hush_stateptrget(base)) != 0 )
-        {
-            *deposited = sp->deposited;
-            *issued = sp->issued;
-            *withdrawn = sp->withdrawn;
-            *approved = sp->approved;
-            *redeemed = sp->redeemed;
-            maxval = sp->approved;
-            if ( sp->withdrawn > maxval )
-                maxval = sp->withdrawn;
-            netliability = (sp->issued - maxval) - sp->shorted;
-            maxallowed = hush_maxallowed(baseid);
-            if ( netliability < maxallowed )
-                *available = (maxallowed - netliability);
-            //printf("%llu - %llu %s %.8f %.8f %.8f %.8f %.8f\n",(long long)maxallowed,(long long)netliability,base,dstr(*deposited),dstr(*issued),dstr(*withdrawn),dstr(*approved),dstr(*redeemed));
-            return(0);
-        } else printf("pax_fiatstatus cant get basesp.%s\n",base);
-    } // else printf("pax_fiatstatus illegal base.%s\n",base);
    return(-1);
 }

@ -210,71 +179,7 @@ int32_t hush_rwapproval(int32_t rwflag,uint8_t *opretbuf,struct pax_transaction

 int32_t hush_issued_opreturn(char *base,uint256 *txids,uint16_t *vouts,int64_t *values,int64_t *srcvalues,int32_t *hushheights,int32_t *otherheights,int8_t *baseids,uint8_t *rmd160s,uint8_t *opretbuf,int32_t opretlen,int32_t iskomodo)
 {
-    struct pax_transaction p,*pax; int32_t i,n=0,j,len=0,incr,height,otherheight; uint8_t type,rmd160[20]; uint64_t fiatoshis; char symbol[HUSH_SMART_CHAIN_MAXLEN];
-    //if ( HUSH_PAX == 0 )
-    //    return(0);
-    incr = 34 + (iskomodo * (2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 4));
-    //41e77b91cb68dc2aa02fa88550eae6b6d44db676a7e935337b6d1392d9718f03cb0200305c90660400000000fbcbeb1f000000bde801006201000058e7945ad08ddba1eac9c9b6c8e1e97e8016a2d152
-
-    // 41e94d736ec69d88c08b5d238abeeca609c02357a8317e0d56c328bcb1c259be5d0200485bc80200000000404b4c000000000059470200b80b000061f22ba7d19fe29ac3baebd839af8b7127d1f9075553440046bb4cc7a3b5cd39dffe7206507a3482a00780e617f68b273cce9817ed69298d02001069ca1b0000000080f0fa02000000005b470200b90b000061f22ba7d19fe29ac3baebd839af8b7127d1f90755
-
-    //for (i=0; i<opretlen; i++)
-    //    printf("%02x",opretbuf[i]);
-    //printf(" opretlen.%d (%s)\n",opretlen,base);
-    //printf(" opretlen.%d vs %d incr.%d (%d)\n",opretlen,(int32_t)(2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 2),incr,opretlen/incr);
-    //if ( SMART_CHAIN_SYMBOL[0] == 0 || strncmp(SMART_CHAIN_SYMBOL,base,strlen(base)) == 0 )
-    {
-        type = opretbuf[0];
-        opretbuf++, opretlen--;
-        for (n=0; n<opretlen/incr; n++)
-        {
-            if ( iskomodo != 0 )
-            {
-                memset(&p,0,sizeof(p));
-                len += hush_rwapproval(0,&opretbuf[len],&p);
-                if ( values != 0 && srcvalues != 0 && hushheights != 0 && otherheights != 0 && baseids != 0 && rmd160s != 0 )
-                {
-                    txids[n] = p.txid;
-                    vouts[n] = p.vout;
-                    values[n] = (strcmp("HUSH3",base) == 0) ? p.puposhis : p.fiatoshis;
-                    srcvalues[n] = (strcmp("HUSH3",base) == 0) ? p.fiatoshis : p.puposhis;
-                    hushheights[n] = p.height;
-                    otherheights[n] = p.otherheight;
-                    memcpy(&rmd160s[n * 20],p.rmd160,20);
-                    baseids[n] = hush_baseid(p.source);
-                    if ( 0 )
-                    {
-                        char coinaddr[64];
-                        bitcoin_address(coinaddr,60,&rmd160s[n * 20],20);
-                        printf(">>>>>>> %s: (%s) fiat %.8f hushheight.%d other.%d -> %s %.8f\n",type=='A'?"approvedA":"issuedX",baseids[n]>=0?CURRENCIES[baseids[n]]:"???",dstr(p.fiatoshis),hushheights[n],otherheights[n],coinaddr,dstr(values[n]));
-                    }
-                }
-            }
-            else
-            {
-                for (i=0; i<4; i++)
-                    base[i] = opretbuf[opretlen-4+i];
-                for (j=0; j<32; j++)
-                {
-                    ((uint8_t *)&txids[n])[j] = opretbuf[len++];
-                    //printf("%02x",((uint8_t *)&txids[n])[j]);
-                }
-                vouts[n] = opretbuf[len++];
-                vouts[n] = (opretbuf[len++] << 8) | vouts[n];
-                baseids[n] = hush_baseid(base);
-                if ( (pax= hush_paxfinds(txids[n],vouts[n])) != 0 )
-                {
-                    values[n] = (strcmp("HUSH3",base) == 0) ? pax->puposhis : pax->fiatoshis;
-                    srcvalues[n] = (strcmp("HUSH3",base) == 0) ? pax->fiatoshis : pax->puposhis;
-                    hushheights[n] = pax->height;
-                    otherheights[n] = pax->otherheight;
-                    memcpy(&rmd160s[n * 20],pax->rmd160,20);
-                }
-            }
-            //printf(" hush_issued_opreturn issuedtxid v%d i.%d opretlen.%d\n",vouts[n],n,opretlen);
-        }
-    }
-    return(n);
+    return 0;
 }

 int32_t hush_paxcmp(char *symbol,int32_t hushheight,uint64_t value,uint64_t checkvalue,uint64_t seed)
@ -624,38 +529,6 @@ int32_t hush_gateway_deposits(CMutableTransaction *txNew,char *base,int32_t toko
    return(0);
 }

-const char *banned_txids[] =
-{
-    "78cb4e21245c26b015b888b14c4f5096e18137d2741a6de9734d62b07014dfca", // vout1 only 233559
-    "00697be658e05561febdee1aafe368b821ca33fbb89b7027365e3d77b5dfede5", //234172
-    "e909465788b32047c472d73e882d79a92b0d550f90be008f76e1edaee6d742ea", //234187
-    "f56c6873748a327d0b92b8108f8ec8505a2843a541b1926022883678fb24f9dc", //234188
-    "abf08be07d8f5b3a433ddcca7ef539e79a3571632efd6d0294ec0492442a0204", //234213
-    "3b854b996cc982fba8c06e76cf507ae7eed52ab92663f4c0d7d10b3ed879c3b0", //234367
-    "fa9e474c2cda3cb4127881a40eb3f682feaba3f3328307d518589024a6032cc4", //234635
-    "ca746fa13e0113c4c0969937ea2c66de036d20274efad4ce114f6b699f1bc0f3", //234662
-    "43ce88438de4973f21b1388ffe66e68fda592da38c6ef939be10bb1b86387041", //234697
-    "0aeb748de82f209cd5ff7d3a06f65543904c4c17387c9d87c65fd44b14ad8f8c", //234899
-    "bbd3a3d9b14730991e1066bd7c626ca270acac4127131afe25f877a5a886eb25", //235252
-    "fa9943525f2e6c32cbc243294b08187e314d83a2870830180380c3c12a9fd33c", //235253
-    "a01671c8775328a41304e31a6693bbd35e9acbab28ab117f729eaba9cb769461", //235265
-    "2ef49d2d27946ad7c5d5e4ab5c089696762ff04e855f8ab48e83bdf0cc68726d", //235295
-    "c85dcffb16d5a45bd239021ad33443414d60224760f11d535ae2063e5709efee", //235296
-    // all vouts banned
-    "c4ea1462c207547cd6fb6a4155ca6d042b22170d29801a465db5c09fec55b19d", //246748
-    "305dc96d8bc23a69d3db955e03a6a87c1832673470c32fe25473a46cc473c7d1", //247204
-    //"43416a0c4da6b1a5c1d375bdbe8f7dc8d44d8f60df593d3376aa8221ec66357e", // vout0 only
-    //"1eb295ed54c47f35cbccd7e7e40d03041f1853581da6d41102a9d8813782b6cb",
-    //"db121e4012222adfc841824984a2a90b7e5b018dd71307822537d58160195e43",
-    //"28f95b8148ac4ae6e09c7380e34422fab41d568a411e53dc94823e36a3d6f386",
-    //"01d8c839463bda2f2f6400ede4611357913684927a767422a8560ead1b22557c",
-    //"6e4980a9e1bd669f4df04732dc6f11b7773b6de88d1abcf89a6b9007d72ef9ac",
-    //"6cc1d0495170bc0e11fd3925297623562e529ea1336b66ea61f8a1159041aed2",
-    //"250875424cece9bcd98cb226b09da7671625633d6958589e3a462bad89ad87cc", // missed
-    //"ea8659011de52f4dac42cda12326064b7b5013b8492f88e33159884ca299aa05", // missed
-    //"ce567928b5490a17244167af161b1d8dd6ff753fef222fe6855d95b2278a35b3", // missed
-};
-
 int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
 {
    if ( k < indallvouts )
@ -665,169 +538,8 @@ int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
    else return(vout == 0);
 }

-int32_t hush_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max)
-{
-    int32_t i;
-    if ( sizeof(banned_txids)/sizeof(*banned_txids) > max )
-    {
-        fprintf(stderr,"hush_bannedset: buffer too small %d vs %d\n",(int32_t)(sizeof(banned_txids)/sizeof(*banned_txids)),max);
-        StartShutdown();
-    }
-    for (i=0; i<sizeof(banned_txids)/sizeof(*banned_txids); i++)
-        array[i] = uint256S(banned_txids[i]);
-    *indallvoutsp = i-2;
-    return(i);
-}
-
 void hush_passport_iteration();

-int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime) // verify above block is valid pax pricing
-{
-    static uint256 array[64]; static int32_t numbanned,indallvouts;
-    int32_t i,j,k,n,ht,baseid,txn_count,activation,num,opretlen,offset=1,errs=0,notmatched=0,matched=0,hushheights[256],otherheights[256]; uint256 hash,txids[256]; char symbol[HUSH_SMART_CHAIN_MAXLEN],base[HUSH_SMART_CHAIN_MAXLEN]; uint16_t vouts[256]; int8_t baseids[256]; uint8_t *script,opcode,rmd160s[256*20]; uint64_t total,subsidy,available,deposited,issued,withdrawn,approved,redeemed,seed; int64_t checktoshis,values[256],srcvalues[256]; struct pax_transaction *pax; struct hush_state *sp; CTransaction tx;
-    activation = 235300;
-    if ( *(int32_t *)&array[0] == 0 )
-        numbanned = hush_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
-    memset(baseids,0xff,sizeof(baseids));
-    memset(values,0,sizeof(values));
-    memset(srcvalues,0,sizeof(srcvalues));
-    memset(rmd160s,0,sizeof(rmd160s));
-    memset(hushheights,0,sizeof(hushheights));
-    memset(otherheights,0,sizeof(otherheights));
-    txn_count = block.vtx.size();
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-    {
-        for (i=0; i<txn_count; i++)
-        {
-            if ( i == 0 && txn_count > 1 && block.vtx[txn_count-1].vout.size() > 0 && block.vtx[txn_count-1].vout[0].nValue == 5000 )
-            {
-                /*
-                if ( block.vtx[txn_count-1].vin.size() == 1 && GetTransaction(block.vtx[txn_count-1].vin[0].prevout.hash,tx,hash,false) && block.vtx[0].vout[0].scriptPubKey == tx.vout[block.vtx[txn_count-1].vin[0].prevout.n].scriptPubKey )
-                    notmatched = 1;
-                */
-                if ( block.vtx[txn_count-1].vin.size() == 1 ) {
-                    uint256 hashNotaryProofVin = block.vtx[txn_count-1].vin[0].prevout.hash;
-                    int fNotaryProofVinTxFound = GetTransaction(hashNotaryProofVin,tx,hash,false);
-                    if (!fNotaryProofVinTxFound) {
-                        // try to search in the same block
-                        BOOST_FOREACH(const CTransaction &txInThisBlock, block.vtx) {
-                            if (txInThisBlock.GetHash() == hashNotaryProofVin) {
-                                fNotaryProofVinTxFound = 1;
-                                tx = txInThisBlock;
-                                hash = block.GetHash();
-                                break;
-                            }
-                        }
-                    }
-                    if ( fNotaryProofVinTxFound && block.vtx[0].vout[0].scriptPubKey == tx.vout[block.vtx[txn_count-1].vin[0].prevout.n].scriptPubKey )
-                        {
-                            notmatched = 1;
-                        }
-                }  
-            }
-            n = block.vtx[i].vin.size();
-            for (j=0; j<n; j++)
-            {
-                for (k=0; k<numbanned; k++)
-                {
-                    if ( block.vtx[i].vin[j].prevout.hash == array[k] && hush_checkvout(block.vtx[i].vin[j].prevout.n,k,indallvouts) != 0 ) //(block.vtx[i].vin[j].prevout.n == 1 || k >= indallvouts)  )
-                    {
-                        printf("banned tx.%d being used at ht.%d txi.%d vini.%d\n",k,height,i,j);
-                        return(-1);
-                    }
-                }
-            }
-        }
-    }
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ||
-         ((ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1) ||
-         NetworkUpgradeActive(height, Params().GetConsensus(), Consensus::UPGRADE_SAPLING) )
-    {
-        n = block.vtx[0].vout.size();
-        int64_t val,prevtotal = 0; int32_t strangeout=0,overflow = 0;
-        total = 0;
-        for (i=1; i<n; i++)
-        {
-            script = (uint8_t *)&block.vtx[0].vout[i].scriptPubKey[0];
-            if ( (val= block.vtx[0].vout[i].nValue) < 0 || val >= MAX_MONEY )
-            {
-                overflow = 1;
-                break;
-            }
-            if ( i > 1 && script[0] != 0x6a && val < 5000 )
-                strangeout++;
-            total += val;
-            if ( total < prevtotal || (val != 0 && total == prevtotal) )
-            {
-                overflow = 1;
-                break;
-            }
-            prevtotal = total;
-        }
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        {
-            if ( overflow != 0 || total > COIN/10 )
-            {
-                if ( height >= activation )
-                {
-                    if ( height > 800000 )
-                        fprintf(stderr,">>>>>>>> <<<<<<<<<< ht.%d illegal nonz output %.8f n.%d\n",height,dstr(block.vtx[0].vout[1].nValue),n);
-                    return(-1);
-                }
-            }
-            else if ( block.nBits == HUSH_MINDIFF_NBITS && total > 0 ) // to deal with fee stealing
-            {
-                fprintf(stderr,"notary mined ht.%d with extra %.8f\n",height,dstr(total));
-                if ( height > HUSH_NOTARIES_HEIGHT1 )
-                    return(-1);
-            }
-            if ( strangeout != 0 || notmatched != 0 )
-            {
-                if ( 0 && strcmp(NOTARY_PUBKEY.c_str(),"03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828") == 0 )
-                    fprintf(stderr,">>>>>>>>>>>>> DUST ht.%d strangout.%d notmatched.%d <<<<<<<<<\n",height,strangeout,notmatched);
-                if ( height > 1000000 && strangeout != 0 )
-                    return(-1);
-            }
-            else if ( height > 814000 )
-            {
-                script = (uint8_t *)&block.vtx[0].vout[0].scriptPubKey[0];
-                //int32_t notary = hush_electednotary(&num,script+1,height,0);
-                //if ( (-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000)) < 0 )
-                //    fprintf(stderr, ">>>>>>> FAILED BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC);
-                //else
-                //    fprintf(stderr, "<<<<<<< VALID BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC);
-                return(-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000));
-            }
-        }
-        else
-        {
-            checktoshis = 0;
-            if ( (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1 )
-            {
-                if ( (checktoshis= hush_checkcommission((CBlock *)&block,height)) < 0 )
-                {
-                    fprintf(stderr,"ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout);
-                    return(-1);
-                }
-            }
-            if ( height > 1 && checktoshis == 0 )
-            {
-                checktoshis = ((uint64_t)GetBlockSubsidy(height, Params().GetConsensus()) - block.vtx[0].vout[0].nValue);
-                // some pools will need to change their pool fee to be (poolfee % - txfees)
-                //checktoshis += txn_count * 0.001; // rely on higher level validations to prevent emitting more coins than actual txfees
-            }
-            if ( height >= 2 && (overflow != 0 || total > checktoshis || strangeout != 0) )
-            {
-                fprintf(stderr,"checkdeposit: ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout);
-                if ( strangeout != 0 )
-                    fprintf(stderr,">>>>>>>>>>>>> %s DUST ht.%d strangeout.%d notmatched.%d <<<<<<<<<\n",SMART_CHAIN_SYMBOL,height,strangeout,notmatched);
-                return(-1);
-            }
-        }
-    }
-    return(0);
-}
-
 const char *hush_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int32_t opretlen,uint256 txid,uint16_t vout,char *source)
 {
    uint8_t rmd160[20],rmd160s[64*20],addrtype,shortflag,pubkey33[33]; int32_t didstats,i,j,n,kvheight,len,tokomodo,hushheight,otherheights[64],hushheights[64]; int8_t baseids[64]; char base[4],coinaddr[64],destaddr[64]; uint256 txids[64]; uint16_t vouts[64]; uint64_t convtoshis,seed; int64_t fee,fiatoshis,puposhis,checktoshis,values[64],srcvalues[64]; struct pax_transaction *pax,*pax2; struct hush_state *basesp; double diff;
--- a/src/hush_globals.h
+++ b/src/hush_globals.h
@ -29,8 +29,6 @@ int32_t hush_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,ui
 int32_t hush_isrealtime(int32_t *hushheightp);
 uint64_t hush_paxtotal();
 int32_t hush_longestchain();
-uint64_t hush_maxallowed(int32_t baseid);
-int32_t hush_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
 int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts);
 pthread_mutex_t hush_mutex;

--- a/src/hush_nSPV_superlite.h
+++ b/src/hush_nSPV_superlite.h
@ -1,5 +1,4 @@
 // Copyright (c) 2016-2023 The Hush developers
-
 /******************************************************************************
 * Copyright © 2014-2019 The SuperNET Developers.                             *
 *                                                                            *
@ -392,8 +391,6 @@ UniValue NSPV_utxoresp_json(struct NSPV_utxoresp *utxos,int32_t numutxos)
        item.push_back(Pair("txid",utxos[i].txid.GetHex()));
        item.push_back(Pair("vout",(int64_t)utxos[i].vout));
        item.push_back(Pair("value",(double)utxos[i].satoshis/COIN));
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-            item.push_back(Pair("interest",(double)utxos[i].extradata/COIN));
        array.push_back(item);
    }
    return(array);
@ -409,8 +406,6 @@ UniValue NSPV_utxosresp_json(struct NSPV_utxosresp *ptr)
    result.push_back(Pair("height",(int64_t)ptr->nodeheight));
    result.push_back(Pair("numutxos",(int64_t)ptr->numutxos));
    result.push_back(Pair("balance",(double)ptr->total/COIN));
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        result.push_back(Pair("interest",(double)ptr->interest/COIN));
    result.push_back(Pair("filter",(int64_t)ptr->filter));
    result.push_back(Pair("lastpeer",NSPV_lastpeer));
    return(result);
--- a/src/hush_nSPV_wallet.h
+++ b/src/hush_nSPV_wallet.h
@ -383,12 +383,7 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a
    mtx.nExpiryHeight = 0;
    mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
    mtx.nVersion = SAPLING_TX_VERSION;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
-        if ( !hush_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-            mtx.nLockTime = (uint32_t)time(NULL) - 777;
-        else
-            mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
-    }
+    mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
        
    memset(used,0,sizeof(used));

@ -402,14 +397,6 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a
            return(result);
        }
        hex = NSPV_signtx(rewardsum,interestsum,retcodes,mtx,txfee,opret,used);
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        {
-            char numstr[64];
-            sprintf(numstr,"%.8f",(double)interestsum/COIN);
-            result.push_back(Pair("rewards",numstr));
-            sprintf(numstr,"%.8f",(double)rewardsum/COIN);
-            result.push_back(Pair("validated",numstr));
-        }
        if ( hex.size() > 0 )
        {
            if ( DecodeHexTx(tx,hex) != 0 )
--- a/src/hush_pax.h
+++ b/src/hush_pax.h
@ -18,213 +18,13 @@

 #include "hush_defs.h"

-#define USD 0
-#define EUR 1
-#define JPY 2
-#define GBP 3
-#define AUD 4
-#define CAD 5
-#define CHF 6
-#define NZD 7
-
-#define CNY 8
-#define RUB 9
-#define MXN 10
-#define BRL 11
-#define INR 12
-#define HKD 13
-#define TRY 14
-#define ZAR 15
-
-#define PLN 16
-#define NOK 17
-#define SEK 18
-#define DKK 19
-#define CZK 20
-#define HUF 21
-#define ILS 22
-#define KRW 23
-
-#define MYR 24
-#define PHP 25
-#define RON 26
-#define SGD 27
-#define THB 28
-#define BGN 29
-#define IDR 30
-#define HRK 31
-
-#define MAX_CURRENCIES 32
-extern char CURRENCIES[][8];
-
-uint64_t M1SUPPLY[] = { 3317900000000, 6991604000000, 667780000000000, 1616854000000, 331000000000, 861909000000, 584629000000, 46530000000, // major currencies
-    45434000000000, 16827000000000, 3473357229000, 306435000000, 27139000000000, 2150641000000, 347724099000, 1469583000000, 749543000000, 1826110000000, 2400434000000, 1123925000000, 3125276000000, 13975000000000, 317657000000, 759706000000000, 354902000000, 2797061000000, 162189000000, 163745000000, 1712000000000, 39093000000, 1135490000000000, 80317000000,
-    100000000 };
-
-#define MIND 1000
-uint32_t MINDENOMS[] = { MIND, MIND, 100*MIND, MIND, MIND, MIND, MIND, MIND, // major currencies
-    10*MIND, 100*MIND, 10*MIND, MIND, 100*MIND, 10*MIND, MIND, 10*MIND, MIND, 10*MIND, 10*MIND, 10*MIND, 10*MIND, 100*MIND, MIND, 1000*MIND, MIND, 10*MIND, MIND, MIND, 10*MIND, MIND, 10000*MIND, 10*MIND, // end of currencies
-10*MIND,
-};
-
-int32_t Peggy_inds[539] = {289, 404, 50, 490, 59, 208, 87, 508, 366, 288, 13, 38, 159, 440, 120, 480, 361, 104, 534, 195, 300, 362, 489, 108, 143, 220, 131, 244, 133, 473, 315, 439, 210, 456, 219, 352, 153, 444, 397, 491, 286, 479, 519, 384, 126, 369, 155, 427, 373, 360, 135, 297, 256, 506, 322, 425, 501, 251, 75, 18, 420, 537, 443, 438, 407, 145, 173, 78, 340, 240, 422, 160, 329, 32, 127, 128, 415, 495, 372, 522, 60, 238, 129, 364, 471, 140, 171, 215, 378, 292, 432, 526, 252, 389, 459, 350, 233, 408, 433, 51, 423, 19, 62, 115, 211, 22, 247, 197, 530, 7, 492, 5, 53, 318, 313, 283, 169, 464, 224, 282, 514, 385, 228, 175, 494, 237, 446, 105, 150, 338, 346, 510, 6, 348, 89, 63, 536, 442, 414, 209, 216, 227, 380, 72, 319, 259, 305, 334, 236, 103, 400, 176, 267, 355, 429, 134, 257, 527, 111, 287, 386, 15, 392, 535, 405, 23, 447, 399, 291, 112, 74, 36, 435, 434, 330, 520, 335, 201, 478, 17, 162, 483, 33, 130, 436, 395, 93, 298, 498, 511, 66, 487, 218, 65, 309, 419, 48, 214, 377, 409, 462, 139, 349, 4, 513, 497, 394, 170, 307, 241, 185, 454, 29, 367, 465, 194, 398, 301, 229, 212, 477, 303, 39, 524, 451, 116, 532, 30, 344, 85, 186, 202, 517, 531, 515, 230, 331, 466, 147, 426, 234, 304, 64, 100, 416, 336, 199, 383, 200, 166, 258, 95, 188, 246, 136, 90, 68, 45, 312, 354, 184, 314, 518, 326, 401, 269, 217, 512, 81, 88, 272, 14, 413, 328, 393, 198, 226, 381, 161, 474, 353, 337, 294, 295, 302, 505, 137, 207, 249, 46, 98, 27, 458, 482, 262, 253, 71, 25, 0, 40, 525, 122, 341, 107, 80, 165, 243, 168, 250, 375, 151, 503, 124, 52, 343, 371, 206, 178, 528, 232, 424, 163, 273, 191, 149, 493, 177, 144, 193, 388, 1, 412, 265, 457, 255, 475, 223, 41, 430, 76, 102, 132, 96, 97, 316, 472, 213, 263, 3, 317, 324, 274, 396, 486, 254, 205, 285, 101, 21, 279, 58, 467, 271, 92, 538, 516, 235, 332, 117, 500, 529, 113, 445, 390, 358, 79, 34, 488, 245, 83, 509, 203, 476, 496, 347, 280, 12, 84, 485, 323, 452, 10, 146, 391, 293, 86, 94, 523, 299, 91, 164, 363, 402, 110, 321, 181, 138, 192, 469, 351, 276, 308, 277, 428, 182, 260, 55, 152, 157, 382, 121, 507, 225, 61, 431, 31, 106, 327, 154, 16, 49, 499, 73, 70, 449, 460, 187, 24, 248, 311, 275, 158, 387, 125, 67, 284, 35, 463, 190, 179, 266, 376, 221, 42, 26, 290, 357, 268, 43, 167, 99, 374, 242, 156, 239, 403, 339, 183, 320, 180, 306, 379, 441, 20, 481, 141, 77, 484, 69, 410, 502, 172, 417, 118, 461, 261, 47, 333, 450, 296, 453, 368, 359, 437, 421, 264, 504, 281, 270, 114, 278, 56, 406, 448, 411, 521, 418, 470, 123, 455, 148, 356, 468, 109, 204, 533, 365, 8, 345, 174, 370, 28, 57, 11, 2, 231, 310, 196, 119, 82, 325, 44, 342, 37, 189, 142, 222, 9, 54, };
-
-uint64_t peggy_smooth_coeffs[sizeof(Peggy_inds)/sizeof(*Peggy_inds)] =	// numprimes.13
-{
-    962714545, 962506087, 962158759, 961672710, 961048151, 960285354, 959384649, 958346426, 957171134, // x.8
-    955859283, 954411438, 952828225, 951110328, 949258485, 947273493, 945156207, 942907532, 940528434, // x.17
-    938019929, 935383089, 932619036, 929728945, 926714044, 923575608, 920314964, 916933485, 913432593, // x.26
-    909813756, 906078486, 902228342, 898264923, 894189872, 890004874, 885711650, 881311964, 876807614, // x.35
-    872200436, 867492300, 862685110, 857780804, 852781347, 847688737, 842505000, 837232189, 831872382, // x.44
-    826427681, 820900212, 815292123, 809605581, 803842772, 798005901, 792097186, 786118864, 780073180, // x.53
-    773962395, 767788778, 761554609, 755262175, 748913768, 742511686, 736058231, 729555707, 723006417, // x.62
-    716412665, 709776755, 703100984, 696387648, 689639036, 682857428, 676045100, 669204315, 662337327, // x.71
-    655446378, 648533696, 641601496, 634651978, 627687325, 620709702, 613721256, 606724115, 599720386, // x.80
-    592712154, 585701482, 578690411, 571680955, 564675105, 557674825, 550682053, 543698699, 536726645, // x.89
-    529767743, 522823816, 515896658, 508988029, 502099660, 495233249, 488390461, 481572928, 474782249, // x.98
-    468019988, 461287675, 454586804, 447918836, 441285195, 434687268, 428126409, 421603932, 415121117, // x.107
-    408679208, 402279408, 395922888, 389610779, 383344175, 377124134, 370951677, 364827785, 358753406, // x.116
-    352729449, 346756785, 340836251, 334968645, 329154729, 323395230, 317690838, 312042206, 306449955, // x.125
-    300914667, 295436891, 290017141, 284655897, 279353604, 274110676, 268927490, 263804394, 258741701, // x.134
-    253739694, 248798623, 243918709, 239100140, 234343077, 229647649, 225013957, 220442073, 215932043, // x.143
-    211483883, 207097585, 202773112, 198510404, 194309373, 190169909, 186091877, 182075118, 178119452, // x.152
-    174224676, 170390565, 166616873, 162903335, 159249664, 155655556, 152120688, 148644718, 145227287, // x.161
-    141868021, 138566528, 135322401, 132135218, 129004542, 125929924, 122910901, 119946997, 117037723, // x.170
-    114182582, 111381062, 108632643, 105936795, 103292978, 100700645, 98159238, 95668194, 93226942, // x.179
-    90834903, 88491495, 86196126, 83948203, 81747126, 79592292, 77483092, 75418916, 73399150, // x.188
-    71423178, 69490383, 67600142, 65751837, 63944844, 62178541, 60452305, 58765515, 57117547, // x.197
-    55507781, 53935597, 52400377, 50901505, 49438366, 48010349, 46616844, 45257246, 43930951, // x.206
-    42637360, 41375878, 40145912, 38946876, 37778185, 36639262, 35529533, 34448428, 33395384, // x.215
-    32369842, 31371249, 30399057, 29452725, 28531717, 27635503, 26763558, 25915365, 25090413, // x.224
-    24288196, 23508216, 22749980, 22013003, 21296806, 20600917, 19924870, 19268206, 18630475, // x.233
-    18011231, 17410035, 16826458, 16260073, 15710466, 15177224, 14659944, 14158231, 13671694, // x.242
-    13199950, 12742625, 12299348, 11869759, 11453500, 11050225, 10659590, 10281262, 9914910, // x.251
-    9560213, 9216856, 8884529, 8562931, 8251764, 7950739, 7659571, 7377984, 7105706, // x.260
-    6842471, 6588020, 6342099, 6104460, 5874861, 5653066, 5438844, 5231969, 5032221, // x.269
-    4839386, 4653254, 4473620, 4300287, 4133059, 3971747, 3816167, 3666139, 3521488, // x.278
-    3382043, 3247640, 3118115, 2993313, 2873079, 2757266, 2645728, 2538325, 2434919, // x.287
-    2335380, 2239575, 2147382, 2058677, 1973342, 1891262, 1812325, 1736424, 1663453, // x.296
-    1593311, 1525898, 1461118, 1398879, 1339091, 1281666, 1226519, 1173569, 1122736, // x.305
-    1073944, 1027117, 982185, 939076, 897725, 858065, 820033, 783568, 748612, // x.314
-    715108, 682999, 652233, 622759, 594527, 567488, 541597, 516808, 493079, // x.323
-    470368, 448635, 427841, 407948, 388921, 370725, 353326, 336692, 320792, // x.332
-    305596, 291075, 277202, 263950, 251292, 239204, 227663, 216646, 206130, // x.341
-    196094, 186517, 177381, 168667, 160356, 152430, 144874, 137671, 130806, // x.350
-    124264, 118031, 112093, 106437, 101050, 95921, 91039, 86391, 81968, // x.359
-    77759, 73755, 69945, 66322, 62877, 59602, 56488, 53528, 50716, // x.368
-    48043, 45505, 43093, 40803, 38629, 36564, 34604, 32745, 30980, // x.377
-    29305, 27717, 26211, 24782, 23428, 22144, 20927, 19774, 18681, // x.386
-    17646, 16665, 15737, 14857, 14025, 13237, 12491, 11786, 11118, // x.395
-    10487, 9890, 9325, 8791, 8287, 7810, 7359, 6933, 6531, // x.404
-    6151, 5792, 5453, 5133, 4831, 4547, 4278, 4024, 3785, // x.413
-    3560, 3347, 3147, 2958, 2779, 2612, 2454, 2305, 2164, // x.422
-    2032, 1908, 1791, 1681, 1577, 1480, 1388, 1302, 1221, // x.431
-    1145, 1073, 1006, 942, 883, 827, 775, 725, 679, // x.440
-    636, 595, 557, 521, 487, 456, 426, 399, 373, // x.449
-    348, 325, 304, 284, 265, 248, 231, 216, 202, // x.458
-    188, 175, 164, 153, 142, 133, 124, 115, 107, // x.467
-    100, 93, 87, 81, 75, 70, 65, 61, 56, // x.476
-    53, 49, 45, 42, 39, 36, 34, 31, 29, // x.485
-    27, 25, 23, 22, 20, 19, 17, 16, 15, // x.494
-    14, 13, 12, 11, 10, 9, 9, 8, 7, // x.503
-    7, 6, 6, 5, 5, 5, 4, 4, 4, // x.512
-    3, 3, 3, 3, 2, 2, 2, 2, 2, // x.521
-    2, 2, 1, 1, 1, 1, 1, 1, 1, // x.530
-    1, 1, 1, 1, 1, 1, 0, 0, // isum 100000000000
-};
-
-uint64_t hush_maxallowed(int32_t baseid)
-{
-    uint64_t mult,val = COIN * (uint64_t)10000;
-    if ( baseid < 0 || baseid >= 32 )
-        return(0);
-    if ( baseid < 10 )
-        val *= 4;
-    mult = MINDENOMS[baseid] / MIND;
-    return(mult * val);
-}
-
-uint64_t hush_paxvol(uint64_t volume,uint64_t price)
-{
-    if ( volume < 10000000000 )
-        return((volume * price) / 1000000000);
-    else if ( volume < (uint64_t)10 * 10000000000 )
-        return((volume * (price / 10)) / 100000000);
-    else if ( volume < (uint64_t)100 * 10000000000 )
-        return(((volume / 10) * (price / 10)) / 10000000);
-    else if ( volume < (uint64_t)1000 * 10000000000 )
-        return(((volume / 10) * (price / 100)) / 1000000);
-    else if ( volume < (uint64_t)10000 * 10000000000 )
-        return(((volume / 100) * (price / 100)) / 100000);
-    else if ( volume < (uint64_t)100000 * 10000000000 )
-        return(((volume / 100) * (price / 1000)) / 10000);
-    else if ( volume < (uint64_t)1000000 * 10000000000 )
-        return(((volume / 1000) * (price / 1000)) / 1000);
-    else if ( volume < (uint64_t)10000000 * 10000000000 )
-        return(((volume / 1000) * (price / 10000)) / 100);
-    else return(((volume / 10000) * (price / 10000)) / 10);
-}
-
-void pax_rank(uint64_t *ranked,uint32_t *pvals)
-{
-    int32_t i; uint64_t vals[32],sum = 0;
-    for (i=0; i<32; i++)
-    {
-        vals[i] = hush_paxvol(M1SUPPLY[i] / MINDENOMS[i],pvals[i]);
-        sum += vals[i];
-    }
-    for (i=0; i<32; i++)
-    {
-        ranked[i] = (vals[i] * 1000000000) / sum;
-        //printf("%.6f ",(double)ranked[i]/1000000000.);
-    }
-    //printf("sum %llu\n",(long long)sum);
-};
-
-#define BTCFACTOR_HEIGHT 466266
-
-double PAX_BTCUSD(int32_t height,uint32_t btcusd)
-{
-    double btcfactor,BTCUSD;
-    if ( height >= BTCFACTOR_HEIGHT )
-        btcfactor = 100000.;
-    else btcfactor = 1000.;
-    BTCUSD = ((double)btcusd / (1000000000. / btcfactor));
-    if ( height >= BTCFACTOR_HEIGHT && height < 500000 && BTCUSD > 20000 && btcfactor == 100000. )
-        BTCUSD /= 100;
-    return(BTCUSD);
-}
-
 int32_t PAX_pubkey(int32_t rwflag,uint8_t *pubkey33,uint8_t *addrtypep,uint8_t rmd160[20],char fiat[4],uint8_t *shortflagp,int64_t *fiatoshisp)
 {
-    if ( rwflag != 0 )
-    {
-        memset(pubkey33,0,33);
-        pubkey33[0] = 0x02 | (*shortflagp != 0);
-        memcpy(&pubkey33[1],fiat,3);
-        dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp);
-        pubkey33[12] = *addrtypep;
-        memcpy(&pubkey33[13],rmd160,20);
-    }
-    else
-    {
-        *shortflagp = (pubkey33[0] == 0x03);
-        memcpy(fiat,&pubkey33[1],3);
-        fiat[3] = 0;
-        dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp);
-        if ( *shortflagp != 0 )
-            *fiatoshisp = -(*fiatoshisp);
-        *addrtypep = pubkey33[12];
-        memcpy(rmd160,&pubkey33[13],20);
-    }
    return(33);
 }

 double PAX_val(uint32_t pval,int32_t baseid)
 {
-    //printf("PAX_val baseid.%d pval.%u\n",baseid,pval);
-    if ( baseid >= 0 && baseid < MAX_CURRENCIES )
-        return(((double)pval / 1000000000.) / MINDENOMS[baseid]);
    return(0.);
 }

@ -232,68 +32,6 @@ void hush_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals)
 {
 }

-uint64_t hush_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed)
-{
-    int32_t i,j,k,ind,zeroes,wt,nonz; int64_t delta; uint64_t lastprice,tolerance,den,densum,sum=0;
-    for (sum=i=zeroes=nonz=0; i<numvotes; i++)
-    {
-        if ( votes[i] == 0 )
-            zeroes++;
-        else sum += votes[i], nonz++;
-    }
-    if ( nonz < (numvotes >> 2) )
-        return(0);
-    sum /= nonz;
-    lastprice = sum;
-    for (i=0; i<numvotes; i++)
-    {
-        if ( votes[i] == 0 )
-            votes[i] = lastprice;
-        else lastprice = votes[i];
-    }
-    tolerance = sum / 50;
-    for (k=0; k<numvotes; k++)
-    {
-        ind = Peggy_inds[(k + seed) % numvotes];
-        i = (int32_t)(ind % numvotes);
-        wt = 0;
-        if ( votes[i] != 0 )
-        {
-            for (j=0; j<numvotes; j++)
-            {
-                if ( votes[j] != 0 )
-                {
-                    if ( (delta= (votes[i] - votes[j])) < 0 )
-                        delta = -delta;
-                        if ( delta <= tolerance )
-                        {
-                            wt++;
-                            if ( wt > (numvotes >> 1) )
-                                break;
-                        }
-                }
-            }
-        }
-        if ( wt > (numvotes >> 1) )
-        {
-            ind = i;
-            for (densum=sum=j=0; j<numvotes; j++)
-            {
-                den = peggy_smooth_coeffs[j];
-                densum += den;
-                sum += (den * votes[(ind + j) % numvotes]);
-                //printf("(%llu/%llu %.8f) ",(long long)sum,(long long)densum,(double)sum/densum);
-            }
-            if ( densum != 0 )
-                sum /= densum;
-            //sum = (sum * basevolume);
-            //printf("paxprice seed.%llx sum %.8f densum %.8f\n",(long long)seed,dstr(sum),dstr(densum));
-            break;
-        }
-    }
-    return(sum);
-}
-
 uint64_t hush_paxpriceB(uint64_t seed,int32_t height,char *base,char *rel,uint64_t basevolume)
 {
    return 0;
--- a/src/hush_utils.h
+++ b/src/hush_utils.h
@ -2335,7 +2335,6 @@ void hush_args(char *argv0)

        if ( (baseid = hush_baseid(SMART_CHAIN_SYMBOL)) >= 0 && baseid < 32 )
        {
-            //hush_maxallowed(baseid);
            if(fDebug) 
                printf("baseid.%d MAX_MONEY.%s %.8f\n",baseid,SMART_CHAIN_SYMBOL,(double)MAX_MONEY/SATOSHIDEN);
        }
@ -2460,8 +2459,6 @@ void hush_args(char *argv0)
        }
    } else BITCOIND_RPCPORT = GetArg("-rpcport", BaseParams().RPCPort());
    HUSH_DPOWCONFS = GetArg("-dpowconfs",dpowconfs);
-    if ( strcmp(SMART_CHAIN_SYMBOL,"CA333LIES") == 0 )
-        HUSH_EXTRASATOSHI = 1;
 }

 void hush_nameset(char *symbol,char *dest,char *source)
@ -2478,11 +2475,13 @@ void hush_nameset(char *symbol,char *dest,char *source)
 struct hush_state *hush_stateptrget(char *base)
 {
    int32_t baseid;
-    if ( base == 0 || base[0] == 0 || strcmp(base,(char *)"KYCSELLOUTS") == 0 )
+    if ( base == 0 || base[0] == 0 ) {
        return(&HUSH_STATES[33]);
-    else if ( (baseid= hush_baseid(base)) >= 0 )
+    } else if ( (baseid= hush_baseid(base)) >= 0 ) {
        return(&HUSH_STATES[baseid+1]);
-    else return(&HUSH_STATES[0]);
+    } else {
+        return(&HUSH_STATES[0]);
+    }
 }

 struct hush_state *hush_stateptr(char *symbol,char *dest)
--- a/src/main.cpp
+++ b/src/main.cpp
@ -1340,22 +1340,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde

    }

-    if (!(tx.IsMint() || tx.vjoinsplit.empty()))
-    {
-        BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32);
-
-        // We rely on libsodium to check that the signature is canonical.
-        // https://github.com/jedisct1/libsodium/commit/62911edb7ff2275cccd74bf1c8aefcc4d76924e0
-        if (crypto_sign_verify_detached(&tx.joinSplitSig[0],
-                                        dataToBeSigned.begin(), 32,
-                                        tx.joinSplitPubKey.begin()
-                                        ) != 0) {
-            return state.DoS(isInitBlockDownload() ? 0 : 100,
-                                error("CheckTransaction(): invalid joinsplit signature"),
-                                REJECT_INVALID, "bad-txns-invalid-joinsplit-signature");
-        }
-    }
-
    if (tx.IsCoinBase())
    {
        if (!ContextualCheckCoinbaseTransaction(slowflag,block,previndex,tx, nHeight,validateprices))
@ -1363,6 +1347,11 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
                                REJECT_INVALID, "bad-txns-invalid-script-data-for-coinbase-time-lock");
    }

+    // Avoid ztx validation during IBD if height is less than latest checkpoint
+    if (fCheckpointsEnabled && (nHeight < Checkpoints::GetTotalBlocksEstimate(Params().Checkpoints())) ) {
+        return true;
+    }
+
    if (!tx.vShieldedSpend.empty() ||
        !tx.vShieldedOutput.empty())
    {
@ -1422,26 +1411,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
 bool CheckTransaction(uint32_t tiptime,const CTransaction& tx, CValidationState &state,
                      libzcash::ProofVerifier& verifier,int32_t txIndex, int32_t numTxs)
 {
-    static uint256 array[64]; static int32_t numbanned,indallvouts; int32_t j,k,n;
-    if ( *(int32_t *)&array[0] == 0 )
-        numbanned = hush_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
-    n = tx.vin.size();
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-    {
-        for (j=0; j<n; j++)
-        {
-            for (k=0; k<numbanned; k++)
-            {
-                if ( tx.vin[j].prevout.hash == array[k] && hush_checkvout(tx.vin[j].prevout.n,k,indallvouts) != 0 ) //(tx.vin[j].prevout.n == 1 || k >= indallvouts) )
-                {
-                    static uint32_t counter;
-                    if ( counter++ < 100 )
-                        printf("MEMPOOL: banned tx.%d being used at ht.%d vout.%d\n",k,(int32_t)chainActive.Tip()->GetHeight(),j);
-                    return(false);
-                }
-            }
-        }
-    }
    // Don't count coinbase transactions because mining skews the count
    if (!tx.IsCoinBase()) {
        transactionsValidated.increment();
@ -5012,7 +4981,6 @@ bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,
    return true;
 }

-int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime);
 int32_t hush_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height);

 bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state,
@ -5134,7 +5102,9 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
        // changing at run-time, from Consensus::Params being a const struct
        unsigned int nNextWork = GetNextWorkRequired(pindexPrev, &block, consensusParams);

-        LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits );
+        if (fDebug) {
+            LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits );
+        }
        if (block.nBits != nNextWork) {
                // Enforce correct nbits at DAA fork height, before that, ignore
                if (nHeight > daaForkHeight) {
@ -5980,7 +5950,7 @@ bool static LoadBlockIndexDB()
    PruneBlockIndexCandidates();

    double progress;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
+    if ( ishush3 ) {
        progress = Checkpoints::GuessVerificationProgress(chainparams.Checkpoints(), chainActive.LastTip());
    } else {
        int32_t longestchain = hush_longestchain();
@ -7692,31 +7662,6 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
                Misbehaving(pfrom->GetId(), nDoS);
            }
        }
-
-    } else if (strCommand == NetMsgType::MEMPOOL) {
-        LOCK2(cs_main, pfrom->cs_filter);
-        //LogPrintf("%s: mempool request from %s",__func__, pfrom->addr.ToString().c_str());
-        // TODO: limit mempool requests per time and per peer
-
-        std::vector<uint256> vtxid;
-        mempool.queryHashes(vtxid);
-        vector<CInv> vInv;
-        BOOST_FOREACH(uint256& hash, vtxid) {
-            CInv inv(MSG_TX, hash);
-            if (pfrom->pfilter) {
-                CTransaction tx;
-                bool fInMemPool = mempool.lookup(hash, tx);
-                if (!fInMemPool) continue; // another thread removed since queryHashes, maybe...
-                if (!pfrom->pfilter->IsRelevantAndUpdate(tx)) continue;
-            }
-            vInv.push_back(inv);
-            if (vInv.size() == MAX_INV_SZ) {
-                pfrom->PushMessage(NetMsgType::INV, vInv);
-                vInv.clear();
-            }
-        }
-        if (vInv.size() > 0)
-            pfrom->PushMessage(NetMsgType::INV, vInv);
    } else if (strCommand == NetMsgType::ALERT) {
 	// Small DoS penalty so peers that send us lots of
 	// duplicate/expired/invalid-signature/whatever alerts
--- a/src/miner.cpp
+++ b/src/miner.cpp
@ -628,8 +628,6 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
        else txNew.nLockTime = std::max((int64_t)(pindexPrev->nTime+1), GetTime());


-        if ( SMART_CHAIN_SYMBOL[0] == 0 && IS_HUSH_NOTARY != 0 && My_notaryid >= 0 )
-            txNew.vout[0].nValue += 5000;
        pblock->vtx[0] = txNew;

        if ( nHeight > 1 && SMART_CHAIN_SYMBOL[0] != 0 && (ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1) && (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0)  && (commission= the_commission((CBlock*)&pblocktemplate->block,(int32_t)nHeight)) != 0 )
@ -1442,8 +1440,6 @@ void static BitcoinMiner()
        if ( hush_baseid(SMART_CHAIN_SYMBOL) < 0 )
            break;
    }
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        hush_chosennotary(&notaryid,chainActive.LastTip()->GetHeight(),NOTARY_PUBKEY33,(uint32_t)chainActive.LastTip()->GetBlockTime());
    if ( notaryid != My_notaryid )
        My_notaryid = notaryid;
    std::string solver;
@ -1573,61 +1569,7 @@ void static BitcoinMiner()
            savebits = pblock->nBits;
            HASHTarget = arith_uint256().SetCompact(savebits);
            roundrobin_delay = ROUNDROBIN_DELAY;
-            if ( SMART_CHAIN_SYMBOL[0] == 0 && notaryid >= 0 )
-            {
-                j = 65;
-                if ( (Mining_height >= 235300 && Mining_height < 236000) || (Mining_height % HUSH_DPOW_GAP) > 64 || (Mining_height % HUSH_DPOW_GAP) == 0 || Mining_height > 1000000 )
-                {
-                    int32_t dispflag = 0;
-                    if ( notaryid <= 3 || notaryid == 32 || (notaryid >= 43 && notaryid <= 45) || notaryid == 51 || notaryid == 52 || notaryid == 56 || notaryid == 57 )
-                        dispflag = 1;
-                    hush_eligiblenotary(pubkeys,mids,blocktimes,&nonzpkeys,pindexPrev->GetHeight());
-                    if ( nonzpkeys > 0 )
-                    {
-                        for (i=0; i<33; i++)
-                            if( pubkeys[0][i] != 0 )
-                                break;
-                        if ( i == 33 )
-                            externalflag = 1;
-                        else externalflag = 0;
-                        if ( IS_HUSH_NOTARY != 0 )
-                        {
-                            for (i=1; i<66; i++)
-                                if ( memcmp(pubkeys[i],pubkeys[0],33) == 0 )
-                                    break;
-                            if ( externalflag == 0 && i != 66 && mids[i] >= 0 )
-                                printf("VIOLATION at %d, notaryid.%d\n",i,mids[i]);
-                            for (j=gpucount=0; j<65; j++)
-                            {
-                                if ( dispflag != 0 )
-                                {
-                                    if ( mids[j] >= 0 )
-                                    {
-                                        if ( mids[j] == notaryid )
-                                            fprintf(stderr,"--<%d>-- ",mids[j]);
-                                        else
-                                            fprintf(stderr,"%d ",mids[j]);
-                                    } else fprintf(stderr,"GPU ");
-                                }
-                                if ( mids[j] == -1 )
-                                    gpucount++;
-                            }
-                            if ( dispflag != 0 )
-                                fprintf(stderr," <- prev minerids from ht.%d notary.%d gpucount.%d %.2f%% t.%u\n",pindexPrev->GetHeight(),notaryid,gpucount,100.*(double)gpucount/j,(uint32_t)time(NULL));
-                        }
-                        for (j=0; j<65; j++)
-                            if ( mids[j] == notaryid )
-                                break;
-                        if ( j == 65 )
-                            HUSH_LASTMINED = 0;
-                    } else fprintf(stderr,"no nonz pubkeys\n");
-                    if ( (Mining_height >= 235300 && Mining_height < 236000) || (j == 65 && Mining_height > HUSH_MAYBEMINED+1 && Mining_height > HUSH_LASTMINED+64) )
-                    {
-                        HASHTarget = arith_uint256().SetCompact(HUSH_MINDIFF_NBITS);
-                        fprintf(stderr,"I am the chosen one for %s ht.%d\n",SMART_CHAIN_SYMBOL,pindexPrev->GetHeight()+1);
-                    } //else fprintf(stderr,"duplicate at j.%d\n",j);
-                } else Mining_start = 0;
-            } else Mining_start = 0;
+            Mining_start = 0;

            //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
            //    HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
--- a/src/pow.cpp
+++ b/src/pow.cpp
@ -503,8 +503,9 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
        nbits = bnTarget.GetCompact();
        nbits = (nbits & 0xfffffffc) | zawyflag;
    }
-    //if(fDebug)
+    if(fDebug) {
        fprintf(stderr,"%s: nbits=%d\n", __func__, nbits);
+    }
    return(nbits);
 }

@ -537,11 +538,15 @@ unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,

    if ( ASSETCHAINS_ADAPTIVEPOW <= 0 ) {
        if (nActualTimespan < params.MinActualTimespan()) {
-            fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() );
+            if(fDebug) {
+                fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() );
+            }
            nActualTimespan = params.MinActualTimespan();
        }
        if (nActualTimespan > params.MaxActualTimespan()) {
-            fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() );
+            if(fDebug) {
+                fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() );
+            }
            nActualTimespan = params.MaxActualTimespan();
        }
    }
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@ -51,7 +51,6 @@ const char *TX="tx"; //used
 const char *HEADERS="headers"; //used
 const char *BLOCK="block"; //used
 const char *GETADDR="getaddr"; //used
-const char *MEMPOOL="mempool"; //used
 const char *PING="ping"; //used
 const char *PONG="pong"; //used
 const char *NOTFOUND="notfound"; //used
@ -96,7 +95,6 @@ const static std::string allNetMessageTypes[] = {
    NetMsgType::HEADERS,
    NetMsgType::BLOCK,
    NetMsgType::GETADDR,
-    NetMsgType::MEMPOOL,
    NetMsgType::PING,
    NetMsgType::PONG,
    NetMsgType::NOTFOUND,
--- a/src/protocol.h
+++ b/src/protocol.h
@ -158,12 +158,6 @@ extern const char* BLOCK;
 * preferably one with lots of IP addresses of other receiving nodes.
 */
 extern const char* GETADDR;
-/**
- * The mempool message requests the TXIDs of transactions that the receiving
- * node has verified as valid but which have not yet appeared in a block.
- * @since protocol version 60002.
- */
-extern const char* MEMPOOL;
 /**
 * The ping message is sent periodically to help confirm that the receiving
 * peer is still connected.
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@ -1061,79 +1061,8 @@ UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk)
 }

 int32_t hush_pending_withdraws(char *opretstr);
-int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 extern char CURRENCIES[][8];

-UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR); char opretbuf[10000*2]; int32_t opretlen,baseid; uint64_t available,deposited,issued,withdrawn,approved,redeemed;
-    if ( fHelp || params.size() != 0 )
-        throw runtime_error("paxpending needs no args\n");
-    LOCK(cs_main);
-    if ( (opretlen= hush_pending_withdraws(opretbuf)) > 0 )
-        ret.push_back(Pair("withdraws", opretbuf));
-    else ret.push_back(Pair("withdraws", (char *)""));
-    for (baseid=0; baseid<32; baseid++)
-    {
-        UniValue item(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
-        if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,CURRENCIES[baseid]) == 0 )
-        {
-            if ( deposited != 0 || issued != 0 || withdrawn != 0 || approved != 0 || redeemed != 0 )
-            {
-                item.push_back(Pair("available", ValueFromAmount(available)));
-                item.push_back(Pair("deposited", ValueFromAmount(deposited)));
-                item.push_back(Pair("issued", ValueFromAmount(issued)));
-                item.push_back(Pair("withdrawn", ValueFromAmount(withdrawn)));
-                item.push_back(Pair("approved", ValueFromAmount(approved)));
-                item.push_back(Pair("redeemed", ValueFromAmount(redeemed)));
-                obj.push_back(Pair(CURRENCIES[baseid],item));
-                a.push_back(obj);
-            }
-        }
-    }
-    ret.push_back(Pair("fiatstatus", a));
-    return ret;
-}
-
-UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    if ( fHelp || params.size() > 4 || params.size() < 2 )
-        throw runtime_error("paxprice \"base\" \"rel\" height\n");
-    LOCK(cs_main);
-    UniValue ret(UniValue::VOBJ); uint64_t basevolume=0,relvolume,seed;
-    std::string base = params[0].get_str();
-    std::string rel = params[1].get_str();
-    int32_t height;
-    if ( params.size() == 2 )
-        height = chainActive.LastTip()->GetHeight();
-    else height = atoi(params[2].get_str().c_str());
-    //if ( params.size() == 3 || (basevolume= COIN * atof(params[3].get_str().c_str())) == 0 )
-        basevolume = 100000;
-    relvolume = hush_paxprice(&seed,height,(char *)base.c_str(),(char *)rel.c_str(),basevolume);
-    ret.push_back(Pair("base", base));
-    ret.push_back(Pair("rel", rel));
-    ret.push_back(Pair("height", height));
-    char seedstr[32];
-    sprintf(seedstr,"%llu",(long long)seed);
-    ret.push_back(Pair("seed", seedstr));
-    if ( height < 0 || height > chainActive.Height() )
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
-    else
-    {
-        CBlockIndex *pblockindex = chainActive[height];
-        if ( pblockindex != 0 )
-            ret.push_back(Pair("timestamp", (int64_t)pblockindex->nTime));
-        if ( basevolume != 0 && relvolume != 0 )
-        {
-            ret.push_back(Pair("price",((double)relvolume / (double)basevolume)));
-            ret.push_back(Pair("invprice",((double)basevolume / (double)relvolume)));
-            ret.push_back(Pair("basevolume",ValueFromAmount(basevolume)));
-            ret.push_back(Pair("relvolume",ValueFromAmount(relvolume)));
-        } else ret.push_back(Pair("error", "overflow or error in one or more of parameters"));
-    }
-    return ret;
-}
-
 UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
    if (fHelp || params.size() < 2 || params.size() > 3)
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@ -154,9 +154,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
    { "z_shieldcoinbase", 3},
    { "z_getoperationstatus", 0},
    { "z_getoperationresult", 0},
-    { "paxprice", 4 },
-    { "paxprices", 3 },
-    { "paxpending", 0 },
    { "notaries", 2 },
    { "minerids", 1 },
    { "kvsearch", 1 },
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@ -332,9 +332,6 @@ static const CRPCCommand vRPCCommands[] =
    { "blockchain",         "gettxoutsetinfo",        &gettxoutsetinfo,        true  },
    { "blockchain",         "verifychain",            &verifychain,            true  },
    { "blockchain",         "getspentinfo",           &getspentinfo,           false },
-    //{ "blockchain",         "paxprice",               &paxprice,               true  },
-    //{ "blockchain",         "paxpending",             &paxpending,             true  },
-    //{ "blockchain",         "paxprices",              &paxprices,              true  },
    { "blockchain",         "notaries",               &notaries,               true  },
    //{ "blockchain",         "height_MoM",             &height_MoM,             true  },
    //{ "blockchain",         "txMoMproof",             &txMoMproof,             true  },
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@ -502,10 +502,5 @@ extern UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk
 extern UniValue minerids(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue kvsearch(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxprices(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk);

 #endif // HUSH_RPCSERVER_H
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@ -203,7 +203,7 @@ bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins,
 CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe, bool compression, int maxOpenFiles) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe, compression, maxOpenFiles) {
 }

-bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
+bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) const {
    return Read(make_pair(DB_BLOCK_FILES, nFile), info);
 }

@ -214,12 +214,12 @@ bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
        return Erase(DB_REINDEX_FLAG);
 }

-bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
+bool CBlockTreeDB::ReadReindexing(bool &fReindexing) const {
    fReindexing = Exists(DB_REINDEX_FLAG);
    return true;
 }

-bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
+bool CBlockTreeDB::ReadLastBlockFile(int &nFile) const {
    return Read(DB_LAST_BLOCK, nFile);
 }

@ -293,7 +293,7 @@ bool CBlockTreeDB::EraseBatchSync(const std::vector<const CBlockIndex*>& blockin
    return WriteBatch(batch, true);
 }

-bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
+bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) const {
    return Read(make_pair(DB_TXINDEX, txid), pos);
 }

@ -304,7 +304,7 @@ bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos>
    return WriteBatch(batch);
 }

-bool CBlockTreeDB::ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) {
+bool CBlockTreeDB::ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) const {
    return Read(make_pair(DB_SPENTINDEX, key), value);
 }

@ -625,7 +625,7 @@ bool CBlockTreeDB::WriteTimestampBlockIndex(const CTimestampBlockIndexKey &block
    return WriteBatch(batch);
 }

-bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int &ltimestamp) {
+bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int &ltimestamp) const {

    CTimestampBlockIndexValue(lts);
    if (!Read(std::make_pair(DB_BLOCKHASHINDEX, hash), lts))
@ -639,7 +639,7 @@ bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
    return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
 }

-bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
+bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) const {
    char ch;
    if (!Read(std::make_pair(DB_FLAG, name), ch))
        return false;
--- a/src/txdb.h
+++ b/src/txdb.h
@ -93,13 +93,13 @@ private:
 public:
    bool WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo);
    bool EraseBatchSync(const std::vector<const CBlockIndex*>& blockinfo);
-    bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo);
-    bool ReadLastBlockFile(int &nFile);
+    bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo) const;
+    bool ReadLastBlockFile(int &nFile) const;
    bool WriteReindexing(bool fReindex);
-    bool ReadReindexing(bool &fReindex);
-    bool ReadTxIndex(const uint256 &txid, CDiskTxPos &pos);
+    bool ReadReindexing(bool &fReindex) const;
+    bool ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) const;
    bool WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> > &list);
-    bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
+    bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) const;
    bool UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> >&vect);
    bool UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue > >&vect);
    bool ReadAddressUnspentIndex(uint160 addressHash, int type,
@ -112,9 +112,9 @@ public:
    bool WriteTimestampIndex(const CTimestampIndexKey &timestampIndex);
    bool ReadTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &vect);
    bool WriteTimestampBlockIndex(const CTimestampBlockIndexKey &blockhashIndex, const CTimestampBlockIndexValue &logicalts);
-    bool ReadTimestampBlockIndex(const uint256 &hash, unsigned int &logicalTS);
+    bool ReadTimestampBlockIndex(const uint256 &hash, unsigned int &logicalTS) const;
    bool WriteFlag(const std::string &name, bool fValue);
-    bool ReadFlag(const std::string &name, bool &fValue);
+    bool ReadFlag(const std::string &name, bool &fValue) const;
    bool LoadBlockIndexGuts();
    bool blockOnchainActive(const uint256 &hash);
    UniValue Snapshot(int top);
--- a/src/wallet/asyncrpcoperation_sendmany.cpp
+++ b/src/wallet/asyncrpcoperation_sendmany.cpp
@ -65,8 +65,9 @@ AsyncRPCOperation_sendmany::AsyncRPCOperation_sendmany(
        std::vector<SendManyRecipient> zOutputs,
        int minDepth,
        CAmount fee,
-        UniValue contextInfo) :
-        tx_(contextualTx), fromaddress_(fromAddress), t_outputs_(tOutputs), z_outputs_(zOutputs), mindepth_(minDepth), fee_(fee), contextinfo_(contextInfo)
+        UniValue contextInfo,
+        CScript opret) :
+        tx_(contextualTx), fromaddress_(fromAddress), t_outputs_(tOutputs), z_outputs_(zOutputs), mindepth_(minDepth), fee_(fee), contextinfo_(contextInfo), opret_(opret)
 {
    assert(fee_ >= 0);

@ -469,6 +470,10 @@ bool AsyncRPCOperation_sendmany::main_impl() {
            }
        }

+        // Add optional OP_RETURN if it exists
+        if ( opret_ != CScript() ) {
+            builder_.AddOpRet(opret_);
+        }
        // Build the transaction
        auto maybe_tx = builder_.Build();
        if (!maybe_tx) {
--- a/src/wallet/asyncrpcoperation_sendmany.h
+++ b/src/wallet/asyncrpcoperation_sendmany.h
@ -62,7 +62,9 @@ public:
        std::vector<SendManyRecipient> zOutputs,
        int minDepth,
        CAmount fee = ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE,
-        UniValue contextInfo = NullUniValue);
+        UniValue contextInfo = NullUniValue,
+        CScript opret = CScript()
+    );
    virtual ~AsyncRPCOperation_sendmany();
    
    // We don't want to be copied or moved around
@ -92,6 +94,7 @@ private:
    CTxDestination fromtaddr_;
    PaymentAddress frompaymentaddress_;
    SpendingKey spendingkey_;
+    CScript opret_ = CScript();
    
    uint256 joinSplitPubKey_;
    unsigned char joinSplitPrivKey_[crypto_sign_SECRETKEYBYTES];
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@ -606,13 +606,11 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 #define HUSH_KVBINARY 2
 #define HUSH_KVDURATION 1440
 #define DRAGON_MAXSCRIPTSIZE 10001
-uint64_t PAX_fiatdest(uint64_t *seedp,int32_t tokomodo,char *destaddr,uint8_t pubkey37[37],char *coinaddr,int32_t height,char *base,int64_t fiatoshis);
 int32_t hush_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t opretlen);
 extern int32_t HUSH_PAX;
 int32_t hush_is_issuer();
 int32_t dragon_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
 int32_t hush_isrealtime(int32_t *hushheightp);
-int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 int32_t hush_kvsearch(uint256 *refpubkeyp,int32_t current_height,uint32_t *flagsp,int32_t *heightp,uint8_t value[DRAGON_MAXSCRIPTSIZE],uint8_t *key,int32_t keylen);
 int32_t hush_kvcmp(uint8_t *refvalue,uint16_t refvaluesize,uint8_t *value,uint16_t valuesize);
 uint64_t hush_kvfee(uint32_t flags,int32_t opretlen,int32_t keylen);
@ -763,86 +761,6 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)
    return ret;
 }

-UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,puposhis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
-    bool fSubtractFeeFromAmount = false;
-    if ( HUSH_PAX == 0 )
-    {
-        throw runtime_error("paxdeposit disabled without -pax");
-    }
-    if ( hush_is_issuer() != 0 )
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "paxdeposit only from KYC");
-    if (!EnsureWalletIsAvailable(fHelp))
-        throw runtime_error("paxdeposit needs wallet"); //return Value::null;
-    if (fHelp || params.size() != 3)
-        throw runtime_error("paxdeposit address fiatoshis base");
-    LOCK2(cs_main, pwalletMain->cs_wallet);
-    CBitcoinAddress address(params[0].get_str());
-    if (!address.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
-    int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN;
-    std::string base = params[2].get_str();
-    std::string dest;
-    height = chainActive.LastTip()->GetHeight();
-    if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,(char *)base.c_str()) != 0 || available < fiatoshis )
-    {
-        fprintf(stderr,"available %llu vs fiatoshis %llu\n",(long long)available,(long long)fiatoshis);
-        throw runtime_error("paxdeposit not enough available inventory");
-    }
-    puposhis = PAX_fiatdest(&seed,0,destaddr,pubkey37,(char *)params[0].get_str().c_str(),height,(char *)base.c_str(),fiatoshis);
-    dest.append(destaddr);
-    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
-    if (!destaddress.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
-    for (i=0; i<33; i++)
-        fprintf(stderr,"%02x",pubkey37[i]);
-    fprintf(stderr," ht.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",height,(char *)params[0].get_str().c_str(),(char *)base.c_str(),(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
-    EnsureWalletIsUnlocked();
-    CWalletTx wtx;
-    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = puposhis / 1000;
-    if ( fee < 10000 )
-        fee = 10000;
-    dragon_rwnum(1,&pubkey37[33],sizeof(height),&height);
-    opretlen = hush_opreturnscript(opretbuf,'D',pubkey37,37);
-    SendMoney(address.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,puposhis);
-    return wtx.GetHash().GetHex();
-}
-
-UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    CWalletTx wtx; std::string dest; int32_t hushheight; uint64_t seed,puposhis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        return(0);
-    if (!EnsureWalletIsAvailable(fHelp))
-        return 0;
-    throw runtime_error("paxwithdraw deprecated");
-    if (fHelp || params.size() != 2)
-        throw runtime_error("paxwithdraw address fiatamount");
-    if ( hush_isrealtime(&hushheight) == 0 )
-        return(0);
-    LOCK2(cs_main, pwalletMain->cs_wallet);
-    CBitcoinAddress address(params[0].get_str());
-    if (!address.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
-    int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN;
-    puposhis = PAX_fiatdest(&seed,1,destaddr,pubkey37,(char *)params[0].get_str().c_str(),hushheight,SMART_CHAIN_SYMBOL,fiatoshis);
-    dest.append(destaddr);
-    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
-    if (!destaddress.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
-    for (i=0; i<33; i++)
-        printf("%02x",pubkey37[i]);
-    printf(" hushheight.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",hushheight,(char *)params[0].get_str().c_str(),SMART_CHAIN_SYMBOL,(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
-    EnsureWalletIsUnlocked();
-    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = fiatoshis / 1000;
-    if ( fee < 10000 )
-        fee = 10000;
-    dragon_rwnum(1,&pubkey37[33],sizeof(hushheight),&hushheight);
-    opretlen = hush_opreturnscript(opretbuf,'W',pubkey37,37);
-    SendMoney(destaddress.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,fiatoshis);
-    return wtx.GetHash().GetHex();
-}

 UniValue listaddressgroupings(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
@ -5001,6 +4919,8 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
    std::vector<SendManyRecipient> taddrRecipients;
    std::vector<SendManyRecipient> zaddrRecipients;
    CAmount nTotalOut = 0;
+    // Optional OP_RETURN data
+    CScript opret;

    bool containsSaplingOutput = false;

@ -5011,8 +4931,9 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
        // sanity check, report error if unknown key-value pairs
        for (const string& name_ : o.getKeys()) {
            std::string s = name_;
-            if (s != "address" && s != "amount" && s!="memo")
+            if (s != "address" && s != "amount" && s!="memo" && s!="opreturn") {
                throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, unknown key: ")+s);
+            }
        }

        string address = find_value(o, "address").get_str();
@ -5034,6 +4955,13 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
        //    throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+address);
        setAddress.insert(address);

+        UniValue opretValue = find_value(o, "opreturn");
+
+        // Create the CScript representation of the OP_RETURN
+        if (!opretValue.isNull()) {
+            opret << OP_RETURN << ParseHex(opretValue.get_str().c_str());
+        }
+
        UniValue memoValue = find_value(o, "memo");
        string memo;
        if (!memoValue.isNull()) {
@ -5207,7 +5135,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)

    // Create operation and add to global queue
    std::shared_ptr<AsyncRPCQueue> q = getAsyncRPCQueue();
-    std::shared_ptr<AsyncRPCOperation> operation( new AsyncRPCOperation_sendmany(builder, contextualTx, fromaddress, taddrRecipients, zaddrRecipients, nMinDepth, nFee, contextInfo) );
+    std::shared_ptr<AsyncRPCOperation> operation( new AsyncRPCOperation_sendmany(builder, contextualTx, fromaddress, taddrRecipients, zaddrRecipients, nMinDepth, nFee, contextInfo, opret) );
    q->addOperation(operation);
    if(fZdebug)
        LogPrintf("%s: Submitted to async queue\n", __FUNCTION__);
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@ -2516,7 +2516,7 @@ void CWallet::DeleteTransactions(std::vector<uint256> &removeTxs) {
        }
    }
 //TODO: the build system should check for malloc_trim support
-#if defined(__unix__)
+#if defined(__linux__)
    malloc_trim(0);
 #else
    // On Mac and Win memory isn't kept back upon vector or list member erase, different garbage collector strategy. No need to force trimming.
@ -3303,7 +3303,7 @@ CAmount CWallet::GetImmatureWatchOnlyBalance() const

 void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl, bool fIncludeZeroValue, bool fIncludeCoinBase) const
 {
-    uint64_t interest,*ptr;
+    uint64_t *ptr;
    vCoins.clear();

    {
@ -3336,34 +3336,8 @@ void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const
                    !IsLockedCoin((*it).first, i) && (pcoin->vout[i].nValue > 0 || fIncludeZeroValue) &&
                    (!coinControl || !coinControl->HasSelected() || coinControl->IsSelected((*it).first, i)))
                {
-                    if ( 1 ) {
-                        uint32_t locktime; int32_t txheight; CBlockIndex *tipindex;
-                        if ( SMART_CHAIN_SYMBOL[0] == 0 && chainActive.LastTip() != 0 && chainActive.LastTip()->GetHeight() >= 60000 )
-                        {
-                            if ( pcoin->vout[i].nValue >= 10*COIN )
-                            {
-                                if ( (tipindex= chainActive.LastTip()) != 0 )
-                                {
-                                    interest = 0;
-                                } else interest = 0;
-                                if ( interest != 0 )
-                                {
-                                    ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                    (*ptr) = interest;
-                                    //pcoin->vout[i].nValue += interest;
-                                } else {
-                                    ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                    (*ptr) = 0;
-                                }
-                            } else {
-                                ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                (*ptr) = 0;
-                            }
-                        } else {
-                            ptr = (uint64_t *)&pcoin->vout[i].interest;
-                            (*ptr) = 0;
-                        }
-                    }
+                    ptr = (uint64_t *)&pcoin->vout[i].interest;
+                    (*ptr) = 0;
                    vCoins.push_back(COutput(pcoin, i, nDepth, (mine & ISMINE_SPENDABLE) != ISMINE_NO));
                }
            }
@ -3799,26 +3773,12 @@ bool CWallet::CreateTransaction(const vector<CRecipient>& vecSend, CWalletTx& wt
                    //a chance at a free transaction.
                    //But mempool inputs might still be in the mempool, so their age stays 0
                    //fprintf(stderr,"nCredit %.8f interest %.8f\n",(double)nCredit/COIN,(double)pcoin.first->vout[pcoin.second].interest/COIN);
-                    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-                    {
-                        interest2 += pcoin.first->vout[pcoin.second].interest;
-                        //fprintf(stderr,"%.8f ",(double)pcoin.first->vout[pcoin.second].interest/COIN);
-                    }
                    int age = pcoin.first->GetDepthInMainChain();
                    if (age != 0)
                        age += 1;
                    dPriority += (double)nCredit * age;
                }
-                //TODO: delete this
-                if ( SMART_CHAIN_SYMBOL[0] == 0 && DONATION_PUBKEY.size() == 66 && interest2 > 5000 )
-                {
-                    CScript scriptDonation = CScript() << ParseHex(DONATION_PUBKEY) << OP_CHECKSIG;
-                    CTxOut newTxOut(interest2,scriptDonation);
-                    int32_t nDonationPosRet = txNew.vout.size() - 1; // dont change first or last
-                    vector<CTxOut>::iterator position = txNew.vout.begin()+nDonationPosRet;
-                    txNew.vout.insert(position, newTxOut);
-                    interest2 = 0;
-                }
+
                CAmount nChange = (nValueIn - nValue + interest2);
 //fprintf(stderr,"wallet change %.8f (%.8f - %.8f) interest2 %.8f total %.8f\n",(double)nChange/COIN,(double)nValueIn/COIN,(double)nValue/COIN,(double)interest2/COIN,(double)nTotalValue/COIN);
                if (nSubtractFeeFromAmount == 0)
--- a/util/checkpoints.pl
+++ b/util/checkpoints.pl
@ -7,16 +7,15 @@ use strict;

 # Generate checkpoint data for use in src/chainparams.cpp
 my $perday  = 1152;
-my $hush    = "./src/hush-cli";
-my $gethash = "$hush getblockhash";
+my $cli     = "./src/hush-cli";
 my $stride  = shift || 1000;
 if ($stride =~ m/help/) {
    print "To generate checkpoint data every 1000 blocks: $0 &> checkpoints.txt\n";
    print "To generate checkpoint data every X blocks: $0 X &> checkpoints.txt\n";
    print "To generate checkpoint data every X blocks starting at height Y: $0 X Y &> checkpoints.txt\n";
+    print "To generate checkpoint data every X blocks starting at height Y for -ac_name CHAIN: $0 X Y CHAIN &> checkpoints.txt\n";
    exit 0;
 }
-
 unless ($stride == int($stride) and $stride >= 0) {
    print "Invalid stride! Must be an integer > 0\n";
    exit 1;
@ -28,8 +27,21 @@ unless ($start_height == int($start_height) and $start_height >= 0) {
    exit 1;
 }

+my $acname = shift;
+if ($acname) {
+    # TODO: is acname valid?
+    $cli .= " -ac_name=$acname";
+    # HSC's by default have a blocktime of 60s
+    $perday = 1440;
+    # Dragonx has a blocktime of 36s
+    $perday = 2400 if ($acname == 'DRAGONX');
+} else {
+    $acname = 'HUSH3';
+}
+
+my $gethash = "$cli getblockhash";
 my $count   = 0;
-my $blocks  = qx{$hush getblockcount};
+my $blocks  = qx{$cli getblockcount};
 if($?) {
    print "ERROR, exiting...\n";
    exit 1;
@ -53,11 +65,11 @@ while (1) {
 	chomp $blockhash;
 	print qq{($block,     uint256S("0x$blockhash"))\n};
 }
-my $time    = qx{$hush getblock $last |grep time|cut -d: -f2| sed 's/,//g'};
+my $time    = qx{$cli getblock $last |grep time|cut -d: -f2| sed 's/,//g'};
 chomp($time);
 # TODO: This is Linux-only and assumes new (not legacy) dir
-my $line1       = qx{grep --text height=$prev   ~/.hush/HUSH3/debug.log};
-my $line2       = qx{grep --text height=$blocks ~/.hush/HUSH3/debug.log};
+my $line1       = qx{grep --text height=$prev   ~/.hush/$acname/debug.log};
+my $line2       = qx{grep --text height=$blocks ~/.hush/$acname/debug.log};
 my $txs_per_day = 2 * $perday; # default estimate is 2 txs per block, on average
 my $total_txs   = 0;
 #print "line1: $line1\n";