Merge branch 'dev' into reduce_memory

7 months ago · 31a6b72caf
32 changed files with 859 additions and 839 deletions
--- a/configure.ac
+++ b/configure.ac
@ -3,7 +3,7 @@ AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 3)
 dnl Must be kept in sync with src/clientversion.h , ugh!
 define(_CLIENT_VERSION_MINOR, 9)
-define(_CLIENT_VERSION_REVISION, 3)
+define(_CLIENT_VERSION_REVISION, 4)
 define(_CLIENT_VERSION_BUILD, 50)
 define(_ZC_BUILD_VAL, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD), m4_eval(_CLIENT_VERSION_BUILD < 50), 1, m4_eval(_CLIENT_VERSION_BUILD - 24), m4_eval(_CLIENT_VERSION_BUILD == 50), 1, , m4_eval(_CLIENT_VERSION_BUILD - 50)))
 define(_CLIENT_VERSION_SUFFIX, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, _CLIENT_VERSION_REVISION-beta$1, m4_eval(_CLIENT_VERSION_BUILD < 50), 1, _CLIENT_VERSION_REVISION-rc$1, m4_eval(_CLIENT_VERSION_BUILD == 50), 1, _CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION-$1)))
--- a/contrib/sda_checkpoints.pl
+++ b/contrib/sda_checkpoints.pl
@ -12,8 +12,8 @@ my $hush    = "./src/hush-cli";
 my $getblock= "$hush getblock";
 my $gethash = "$hush getblockhash";
 my $gettree = "$hush getblockmerkletree";
-my $start   = shift || 1190000;
-my $end     = shift || 1260000;
+my $start   = shift || 1390000;
+my $end     = shift || 1422000;
 my $stride  = shift || 10000;

 my $blocks  = qx{$hush getblockcount};
@ -41,8 +41,12 @@ while (1) {
    chomp $merkle;
    chomp $blockhash;
    chomp $blocktime;
-    $blocktime =~ s/^\s+|\s+$//g ;
-    print qq{{\n\t"network": "main",\n\t"height": "$block",\n\t"hash": "$blockhash",\n\t$blocktime\n\t"saplingTree": "$merkle"\n},\n};
+    $blocktime =~ s/^\s+|\s+$//g;
+    my $checkpoint = qq{{\n\t"network": "main",\n\t"height": "$block",\n\t"hash": "$blockhash",\n\t$blocktime\n\t"saplingTree": "$merkle"\n}\n};
+    my $filename = "$block.json";
+    open(FH, '>', $filename) or die $!;
+    print FH $checkpoint;
+    close(FH);

    $block += $stride;
 }
--- a/contrib/seeds/nodes_main.txt
+++ b/contrib/seeds/nodes_main.txt
@ -16,6 +16,9 @@
 # lite.hushpool.is
 149.28.102.219

+# lite2.hushpool.is
+155.138.228.68
+
 # wtfistheinternet.hush.is
 107.174.70.251

--- 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/libcurl.mk
+++ b/depends/packages/libcurl.mk
@ -1,9 +1,17 @@
 package=libcurl
+
+ifeq ($(host_os),mingw32)
+$(package)_version=7.67.0
+$(package)_file_name=curl-$($(package)_version).tar.gz
+$(package)_sha256_hash=52af3361cf806330b88b4fe6f483b6844209d47ae196ac46da4de59bb361ab02
+else
 $(package)_version=7.77.0
-$(package)_dependencies=wolfssl
-$(package)_download_path=https://curl.haxx.se/download
 $(package)_file_name=curl-$($(package)_version).tar.gz
 $(package)_sha256_hash=b0a3428acb60fa59044c4d0baae4e4fc09ae9af1d8a3aa84b2e3fbcd99841f77
+endif
+
+$(package)_dependencies=wolfssl
+$(package)_download_path=https://curl.haxx.se/download
 $(package)_config_opts_linux=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=$(host)
 $(package)_config_opts_mingw32=--enable-mingw --disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=x86_64-w64-mingw32
 $(package)_config_opts_darwin=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix)
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@ -104,6 +104,30 @@ We should also check a recent block height to verify it's working correctly. The
  * If you stop a node, and restart, are the stats from `getchaintxtstats` correct, i.e. the anonset stats? For instance, `shielded_pool_size` should be close to 500000, if it's close to or exactly 0, something is wrong.
  * Is there a new file called `zindex.dat` in `~/.hush/HUSH3/` ? 
  * Is `zindex.dat` 149 bytes ?
+
+# Adding a PoW algorithm
+
+We will describe here the high-level ideas on how to add a new PoW algorithm to
+the Hush codebase. Adding a new PoW algo means adding a new option to the `-ac_algo`
+CLI param for HSC's.
+
+  * Add the new value to the end of the `ASSETCHAINS_ALGORITHMS` array in `src/hush_utils.h`
+    * You cannot add it to the front because the first element is the default "equihash"
+    * You will also need to add a new constant, such as `ASSETCHAINS_FOOHASH` to `src/hush_globals.h`
+  * Increase the value of `ASSETCHAINS_NUMALGOS` by one
+    * This value cannot be automatically be determined by the length of the above array because Equihash has different supported variants of (N,K) values
+  * Add the new PoW mining library to a subdirectory in src, such as RandomX official code being in `src/RandomX`
+  * The largest part of adding a new PoW algo is adding a new class to src/miner.cpp
+    * Originally there was only BitcoinMiner, which was modified from a double-sha256 miner to an equihash miner, without changing the name
+    * When RandomX was added as an option, many big internals changes were needed to support more than a single miner class
+    * It is now easier to add PoW algos because the internals support using different miner classes
+  * Currently BitcoinMiner and RandomXMiner classes have a lot of duplicated code, but this is intentional
+    * In theory we could refactor the miner classes to share more code, but this means changes to one miner could break another and it is very challenging to test every possibile edge case for mining code
+    * So code duplication is purposeful, because it isolates the risk of breaking one PoW by changing another. We tried very hard to not break Equihash mining when adding RandomX mining.
+    * When adding a new mining class, copying the RandomXMiner class is best, since it's newer and does not contain various legacy code that still exists in BitcoinMiner
+    * So copy RandomXMiner to your new FooMiner, delete all the randomx-specific stuff and add in the PoW mining code
+  * Some other changes to src/miner.cpp will be needed
+    * Update `GenerateBitcoins` function to start mining threads with your new algo with  `else if(ASSETCHAINS_ALGO == ASSETCHAINS_FOOHASH) { minerThreads->create_thread(&FooMiner)}`
  
 # Coding

--- a/doc/man/hush-cli.1
+++ b/doc/man/hush-cli.1
@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSH-CLI "1" "February 2023" "hush-cli v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSH-CLI "1" "June 2023" "hush-cli v3.9.4" "User Commands"
 .SH NAME
-hush-cli \- manual page for hush-cli v3.9.3
+hush-cli \- manual page for hush-cli v3.9.4
 .SH DESCRIPTION
-Hush RPC client version v3.9.3\-1313d39a7
+Hush RPC client version v3.9.4\-44595d5ab
 .PP
 In order to ensure you are adequately protecting your privacy when using Hush,
 please see <https://hush.is/security/>.
--- a/doc/man/hush-tx.1
+++ b/doc/man/hush-tx.1
@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSH-TX "1" "February 2023" "hush-tx v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSH-TX "1" "June 2023" "hush-tx v3.9.4" "User Commands"
 .SH NAME
-hush-tx \- manual page for hush-tx v3.9.3
+hush-tx \- manual page for hush-tx v3.9.4
 .SH DESCRIPTION
-hush\-tx utility version v3.9.3\-1313d39a7
+hush\-tx utility version v3.9.4\-44595d5ab
 .SS "Usage:"
 .TP
 hush\-tx [options] <hex\-tx> [commands]
--- a/doc/man/hushd.1
+++ b/doc/man/hushd.1
@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSHD "1" "February 2023" "hushd v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSHD "1" "June 2023" "hushd v3.9.4" "User Commands"
 .SH NAME
-hushd \- manual page for hushd v3.9.3
+hushd \- manual page for hushd v3.9.4
 .SH DESCRIPTION
-Hush Daemon version v3.9.3\-1313d39a7
+Hush Daemon version v3.9.4\-44595d5ab
 .PP
 In order to ensure you are adequately protecting your privacy when using Hush,
 please see <https://hush.is/security/>.
@ -78,7 +78,7 @@ applied)
 .HP
 \fB\-par=\fR<n>
 .IP
-Set the number of script verification threads (\fB\-8\fR to 16, 0 = auto, <0 =
+Set the number of script verification threads (\fB\-6\fR to 16, 0 = auto, <0 =
 leave that many cores free, default: 0)
 .HP
 \fB\-pid=\fR<file>
--- a/doc/release-process.md
+++ b/doc/release-process.md
@ -76,6 +76,7 @@ Install deps on Linux:
     - Comment out the HUSHVER line and uncomment the line above it with a hardcoded version number
   - PROTIP: Man page creation must be done after updating the version number and recompiling and before Debian package creation
 - Update checkpoints in src/chainparams.cpp via util/checkpoints.pl
+   - Run "./util/checkpoints.pl help" to get example usage
   - hushd must be running to run this script, since it uses hush-cli to get the data
   - Look for line which says "END HUSH mainnet checkpoint data" near line 560 in chainparams.cpp , that is where checkpoint data ends
   - Find the highest block height of checkpoint data, let's call it HEIGHT
@ -95,6 +96,7 @@ Install deps on Linux:
     - They only provide limited security, because they talk about the past, not future block heights.
   - Try to generate checkpoints as close to the release as possible, so you can have a recent block height be protected.
     - For instance, don't update checkpoints and then do a release a month later. You can always update checkpoint data again or multiple times
+   - DRAGONX now has checkpoints, you can generate them with: `./util/checkpoints.pl 1000 1 DRAGONX`
 - Update copyright years if applicable. Example: `./util/update-copyrights.h 2022 2023`
 - Update doc/relnotes/README.md
   - To get the stats of file changes: `git diff --stat master...dev`
--- a/doc/relnotes/README.md
+++ b/doc/relnotes/README.md
@ -10,6 +10,34 @@ and no longer on Github, since they banned Duke Leto and
 also because they censor many people around the world and work with
 evil organizations.

+# Hush 3.9.4 "Maniacal Manticore"
+
+```
+68 files changed, 1304 insertions(+), 1343 deletions(-)
+```
+
+This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release.
+
+  * New features and improvements
+    * Hush and DragonX nodes will now sync much faster
+    * DragonX now has checkpoints for faster better chain security
+    * Updated to the latest RandomX code
+	* Rate limiting for the processing of incoming addr messages for increased security.
+	* Removed unused function CWalletTx::GetRequestCount
+	* Removed mapRequest tracking that only affects Qt display.
+	* Randomized message processing peer order for increased privacy.
+	* Removed BIP35 mempool p2p message for increased privacy.
+	* Additional community seed node
+  * Build Improvements
+	* Use custom jobs param when compiling boost for faster compile times
+	* Now builds with gcc13 thanks to testing from jahway
+	* We have an aarch64 deb now thanks to jahway
+  * Bug fixes:
+	* -stratumallowip works with CIDR and netmask ranges again for solo miners
+	* Detect missing autoreconf in build.sh
+	* Various assertions removed from BIP155 changes in previous release. 
+
+
 # Hush 3.9.3 "Lateral Larvacean"

 ```
--- 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/CCMarmara.h
+++ b/src/cc/CCMarmara.h
@ -1,53 +0,0 @@
-// Copyright (c) 2016-2023 The Hush developers
-// Distributed under the GPLv3 software license, see the accompanying
-// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
-/******************************************************************************
- * Copyright © 2014-2019 The SuperNET Developers.                             *
- *                                                                            *
- * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
- * the top-level directory of this distribution for the individual copyright  *
- * holder information and the developer policies on copyright and licensing.  *
- *                                                                            *
- * Unless otherwise agreed in a custom licensing agreement, no part of the    *
- * SuperNET software, including this file may be copied, modified, propagated *
- * or distributed except according to the terms contained in the LICENSE file *
- *                                                                            *
- * Removal or modification of this copyright notice is prohibited.            *
- *                                                                            *
- ******************************************************************************/
-
-
-#ifndef CC_MARMARA_H
-#define CC_MARMARA_H
-
-/*
-
-#include "CCinclude.h"
-#include "../hush_cJSON.h"
-
-#define MARMARA_GROUPSIZE 60
-#define MARMARA_MINLOCK (1440 * 3 * 30)
-#define MARMARA_MAXLOCK (1440 * 24 * 30)
-#define MARMARA_VINS 16
-#define EVAL_MARMARA 0xef
-
-extern uint8_t ASSETCHAINS_MARMARA;
-uint64_t hush_block_prg(uint32_t nHeight);
-int32_t MarmaraGetcreatetxid(uint256 &createtxid,uint256 txid);
-int32_t MarmaraGetbatontxid(std::vector<uint256> &creditloop,uint256 &batontxid,uint256 txid);
-UniValue MarmaraCreditloop(uint256 txid);
-UniValue MarmaraSettlement(uint64_t txfee,uint256 batontxid);
-UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height);
-
-UniValue MarmaraPoolPayout(uint64_t txfee,int32_t firstheight,double perc,char *jsonstr); // [[pk0, shares0], [pk1, shares1], ...]
-UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid,bool automaticflag);
-UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 approvaltxid,uint256 batontxid);
-UniValue MarmaraInfo(CPubKey refpk,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,std::string currency);
-
-bool MarmaraValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
-
-// CCcustom
-UniValue MarmaraInfo();
-*/
-
-#endif
--- a/src/cc/CCcustom.cpp
+++ b/src/cc/CCcustom.cpp
@ -30,7 +30,6 @@
 #include "CCOracles.h"
 #include "CCPrices.h"
 #include "CCPegs.h"
-#include "CCMarmara.h"
 #include "CCPayments.h"
 #include "CCGateways.h"
 #include "CCtokens.h"
@ -192,17 +191,6 @@ uint8_t PegsCCpriv[32] = { 0x52, 0x56, 0x4c, 0x78, 0x87, 0xf7, 0xa2, 0x39, 0xb0,
 #undef FUNCNAME
 #undef EVALCODE

-// Marmara
-#define FUNCNAME IsMarmaraInput
-#define EVALCODE EVAL_MARMARA
-const char *MarmaraCCaddr = "RGLSRDnUqTB43bYtRtNVgmwSSd1sun2te8";
-const char *MarmaraNormaladdr = "RMN25Tn8NNzcyQDiQNuMp8UmwLMFd9thYc";
-char MarmaraCChexstr[67] = { "03afc5be570d0ff419425cfcc580cc762ab82baad88c148f5b028d7db7bfeee61d" };
-uint8_t MarmaraCCpriv[32] = { 0x7c, 0x0b, 0x54, 0x9b, 0x65, 0xd4, 0x89, 0x57, 0xdf, 0x05, 0xfe, 0xa2, 0x62, 0x41, 0xa9, 0x09, 0x0f, 0x2a, 0x6b, 0x11, 0x2c, 0xbe, 0xbd, 0x06, 0x31, 0x8d, 0xc0, 0xb9, 0x96, 0x76, 0x3f, 0x24 };
-#include "CCcustom.inc"
-#undef FUNCNAME
-#undef EVALCODE
-
 // Payments
 #define FUNCNAME IsPaymentsInput
 #define EVALCODE EVAL_PAYMENTS
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@ -1547,13 +1547,697 @@ void *chainparams_commandline() {
                (1249000,     uint256S("0x00000001170d6ae54d494bd2dbf29c5ab7f560f51874987d7dbe129d549c097f"))
                (1250000,     uint256S("0x000000033226eef40d094c8aa88d03bbc9146856c52248760e28c45426787352"))
                (1251000,     uint256S("0x0000000281c7f7ef75ac6539791e26b9744cccd59414b04ddc4697bcd3595209"))
-                ,(int64_t)  1675926362, // time of last checkpointed block
-                (int64_t) 2022392,      // total txs
-                (double)  1371        // txs in the last day before block 1251770
+
+		// Generated at 1688095440 via hush3 util/checkpoints.pl by fekt
+		(1252000,     uint256S("0x00000002a23866c4bc24b6d14b8039eb38530936fd7ba230cd41bbffe457c0eb"))
+		(1253000,     uint256S("0x000000021fb79ebfda0aa2dde15ef1fc669003911bc771d1700f8b6785d86aa9"))
+		(1254000,     uint256S("0x000000020083112cbd6ac00fff2dbbd4c72e3c1d2636138cd42a63b7fc0af798"))
+		(1255000,     uint256S("0x00000000247e68c0c4bd2cffedf9dff84dc67e49f9c90b6df073d4c6e913856a"))
+		(1256000,     uint256S("0x00000002556455ce2059602aa43b7dc0ed5014bc157e78e9283bc2610946720e"))
+		(1257000,     uint256S("0x00000003119deacf7b787311ef767abb173594d22979797a58a2ad01b7bda0a5"))
+		(1258000,     uint256S("0x000000024edab00216ccb7ef39dd16b782e14179f90aace0d812b33ecbefdde0"))
+		(1259000,     uint256S("0x00000003016ee9e404906afe5542afa1b614be768187d8a9f9c7ebf598d76695"))
+		(1260000,     uint256S("0x00000000b7fc90789fca4e53b5966707642d1d9ffcccc99c28fd194135d08618"))
+		(1261000,     uint256S("0x00000001e43bbacba953a662435791e7f4bc1c3fada97d8a279c8b26598fecc7"))
+		(1262000,     uint256S("0x00000002993a7913e93d68bf44bd0f5c0102a7ab196ed6ee4ae9ea790b197854"))
+		(1263000,     uint256S("0x000000016bf7677b49e8df24d03c3ba6ab060356c72501de94938ad2e7be946c"))
+		(1264000,     uint256S("0x00000002c616eed07db9e4695ac9cee6989e42a76c6f61a4e0ebe0bb5abf692f"))
+		(1265000,     uint256S("0x000000024d31a0ef0a466f573bb7c0e0970fc52e895c3b01d95b5b38e81322ca"))
+		(1266000,     uint256S("0x000000011e54e3519dd6ea6af0443e309c8e226e2ccd775b28cc4f12f08c0d39"))
+		(1267000,     uint256S("0x0000000393da90dc30fde8005d7f2d2318f8785e2a32bc865bf8383f7c8ffea8"))
+		(1268000,     uint256S("0x000000027f04b7efb776bd8420de4cc0228561aa773d59cb0b2e9f6025389322"))
+		(1269000,     uint256S("0x000000061807ebcde0469dd2c3b3bf682864b593da8bc8c64d354108961a6514"))
+		(1270000,     uint256S("0x00000000041c198471a04f305344aeae7650140175c97d62765861d6416a4ed1"))
+		(1271000,     uint256S("0x00000001f0e911e3ce304f9785f4c43ae7087eca9c4cadc677c4f49659b121dc"))
+		(1272000,     uint256S("0x000000035098a7b17ae7be1c6decf88dbca85562137c8d2200bd84cb59148788"))
+		(1273000,     uint256S("0x00000005d5d27e58ecb84658d2c3f2d8c87bae08ee0d81c6d4cdfc347ec13ec9"))
+		(1274000,     uint256S("0x00000001623cd2acb0005393f2378a2d1ed5603511ee806b1e04f4e677b7531b"))
+		(1275000,     uint256S("0x0000000140a568b0870d2c6853fe3fdcd94193652ef61ba9d430989e9a521a77"))
+		(1276000,     uint256S("0x000000046e660edfdbae93511bb48f335df7523bae3cd5bfcb77cd81525585bb"))
+		(1277000,     uint256S("0x000000022c296e5406126bbd6040316b2706c489c58d2b7593e1ec1637d31432"))
+		(1278000,     uint256S("0x000000012b5d649609b503398d7af1fa7e14e9e58bd8e6746d6f44bbeb311270"))
+		(1279000,     uint256S("0x000000039deede9e29ba8c7178df43374e83d6691556103a337c58822f2501fc"))
+		(1280000,     uint256S("0x0000000172d327c94631b30e851ada193ad0d4b05a659db7e92cdaf4a5859841"))
+		(1281000,     uint256S("0x00000002cf093cdd98e566534b7b5aaa91ee125e71283d654a75b878f08ba015"))
+		(1282000,     uint256S("0x0000000306c146a88cd6a2cce453ac72d632a9bebf49abf27c684b4957f8380a"))
+		(1283000,     uint256S("0x00000004738db155d0d8b5d95abd4484962c16a40eab2047b5b20fa4c5df890e"))
+		(1284000,     uint256S("0x00000001bba05b8445a32d3856a1e4dbe9f65a96c39ca92c654ac01e675b1076"))
+		(1285000,     uint256S("0x00000002fbc4853d6183b848e5ad32637478358521e87a7c1febfde93c4dcaa8"))
+		(1286000,     uint256S("0x00000002fd09e8f12b1ade668a238b4badda452869f770c20bf3edd0c9a2b984"))
+		(1287000,     uint256S("0x0000000568e3a41c8ac6e4d5ed59630a1aeff0b957494388a4c939f206ecac0c"))
+		(1288000,     uint256S("0x000000024cf90a1150d224e167503dd79d2261de0e5e7a7e35b04949c95b8fd6"))
+		(1289000,     uint256S("0x00000004ecdab6f1bf5f2cfd924afefb167160a49d5aa9a2b4790b4fce190427"))
+		(1290000,     uint256S("0x0000000305db71205f1c622693cc55fee7c3b7c26400e13e82b3855a13c40df7"))
+		(1291000,     uint256S("0x000000032d1115be00930015cb1f6fe824349bd4ff367ec675c4c92d7b268904"))
+		(1292000,     uint256S("0x00000000a0fa63c1264eadb0fd86f1f420c74c2b5593604897c6ebe4aa4691b5"))
+		(1293000,     uint256S("0x00000002bfd681e56afbb24664cd056812d1347bab971b44ff957a7ecd4a54ce"))
+		(1294000,     uint256S("0x00000000ba8ac906a4fea8b779d6272e2648a30a488c4c390f1c761fbf53e76d"))
+		(1295000,     uint256S("0x00000000859df3b6859bdd415b8d1b1fb8c396a279c8ddd6b1f39d41cec89579"))
+		(1296000,     uint256S("0x000000008e62f687dc9899200671a9c595e1626e29477080ab052be584349ba5"))
+		(1297000,     uint256S("0x00000003e9d6c1cce45b1d76a775f3d6e6ebbd5caa62427ae015e954e1f14d05"))
+		(1298000,     uint256S("0x00000000fa5a495e60cfe2c8de8d8e52c2bb1ddf335a891f69be2c7eae901dcc"))
+		(1299000,     uint256S("0x0000000326ff88c4546f65313522fe9466b33e96af50e6a6db09dfe59193bc63"))
+		(1300000,     uint256S("0x00000003f498d56accc70c7257bfd708a22128dda0a038499f0c984f3e9ba2c0"))
+		(1301000,     uint256S("0x00000001313da1129ba7de5f415d211ea1e3f51ae9d910abb2624aeae15b4a56"))
+		(1302000,     uint256S("0x000000034cdf6686f4350dcc4f1f0887bb128746afd7cc3aeba5bf8b000c636f"))
+		(1303000,     uint256S("0x00000003dffb121ae41569ca13d851f3c45668e8ee351680c2db1871f251eb3e"))
+		(1304000,     uint256S("0x00000000c5bb42d8bfe94087c5d129fafe2677e62edadfaa7415b8a7bb4277ff"))
+		(1305000,     uint256S("0x0000000046e1db3cc0047a85b815b745c4a0f4af4244b79d90a57cfafdf85699"))
+		(1306000,     uint256S("0x00000004418d213a0ecced05de5b1fcaca70fe272d37773377e02c1873d27068"))
+		(1307000,     uint256S("0x00000001cce1afda2c61046fd571edf01bdcc5a09260fcc7727caca8e3eb6ed6"))
+		(1308000,     uint256S("0x00000000a453c4fd6f537776b730e5b8ae4d238c2f9215ed4f6e709b8aa177ac"))
+		(1309000,     uint256S("0x000000009c9d7cb8f66d9ccdb7ce77a3c36c8d7df74e21326ef86000627091d4"))
+		(1310000,     uint256S("0x00000000cd97fe334d3be6f3fda419589ebf643bffab3194d5cdeb7d324d123c"))
+		(1311000,     uint256S("0x00000004fd9a887ae0db3333544e3027fe79f59fbdf8116ca516650e165bcd52"))
+		(1312000,     uint256S("0x0000000349b8956bf4cf1b9566580e7362dfdd512ac5f7ef6a300ce2c0cf343e"))
+		(1313000,     uint256S("0x000000030a692fe283bdbc7e1e11f8827da5a1e7b4aa3cca3c089803af547025"))
+		(1314000,     uint256S("0x000000034e3ff90ae3436af4d7e1caec9604c5d347bded5fc6e0b05f3d0902f8"))
+		(1315000,     uint256S("0x000000011044536fe0741ffb747e3b0f0cf826b3103d50b41f392772ed55607c"))
+		(1316000,     uint256S("0x000000022ca70a448e4f6693aafeb5f0eac948064188933a01cd15db835e1bc3"))
+		(1317000,     uint256S("0x00000005b8f471f902a540463c5a8ce962a34da30157bb4c094bbfee85b3ad36"))
+		(1318000,     uint256S("0x000000020bada11214b8cf7784286aa4e5120c14b5b5e47516f619e6411badc0"))
+		(1319000,     uint256S("0x00000001642ce9e76b5ebe167b03fdd00d0e6d595abb09ee9bd6c033f947f2db"))
+		(1320000,     uint256S("0x00000000995d4bafd5b3e9bcc709cf0623090008aa34c9ee6b44c815ad08bc48"))
+		(1321000,     uint256S("0x00000001bd0fff7aff0e313d8b458568a65a395d037b6d2999328798c441d8d3"))
+		(1322000,     uint256S("0x000000015cd85c1fc0fc6877cb6c9ff4d9ab99bc7ece23d96c468c549ee3e368"))
+		(1323000,     uint256S("0x000000033cdd6bc9051d956dc774e7c8066ae6f2272f2cbd23a5cb34a6f21947"))
+		(1324000,     uint256S("0x00000001feaf5da15ade7a2a7f039ef95f506dfa7c8d7a3077dc6b77106a4aa9"))
+		(1325000,     uint256S("0x00000002ed58d3afaa3044dde92a4af3908c154895651c46b8ad24bdcd702021"))
+		(1326000,     uint256S("0x0000000377de030a756db011af1cf8d6ea1cabec0ad4957055de3435ee1102bf"))
+		(1327000,     uint256S("0x00000002b68d85dc8783068c6878f128c048aa85dae10c5e0495768e76b153a8"))
+		(1328000,     uint256S("0x000000022c5ea4c4f470006d99898a1de5d783967dfc4f0759835f60a0f376d9"))
+		(1329000,     uint256S("0x0000000448c2f62ad26c51c3481b702615acf71f40631dc384e081e579993bf2"))
+		(1330000,     uint256S("0x000000004bfdeafb2dcdbb7b0a214c62fc4f03583f3f6f27bbe2dd78c083bc6a"))
+		(1331000,     uint256S("0x0000000008f29e6bfeedea18387ec2df4f1518f03de03073bd402d3d84daa40d"))
+		(1332000,     uint256S("0x00000003b6b0fdb24bcd5b132ab25d97ce116d4fce4edc70037848340f9cd6a0"))
+		(1333000,     uint256S("0x0000000540eb80533c3ad5fb11028ef74e41cf66afeeb49d38c8e91e1b9be071"))
+		(1334000,     uint256S("0x000000024e829222c6b338723ea69a1aaf8ca426db6f1dc5ed6a508aa4eba324"))
+		(1335000,     uint256S("0x00000001c34ef432a6d7c5b537e4157bcdc6a2f4c3d30d25cb9bb47ff395b5a6"))
+		(1336000,     uint256S("0x000000011cda647d4405fbcffc35ce161a057911bc551290848a56a832835c14"))
+		(1337000,     uint256S("0x0000000297dddb61d28cd456b11c6683f5c040ea1d798462cba45ff4d9acb7aa"))
+		(1338000,     uint256S("0x000000031a44d98fee4c721d7cf692b5c6d49c72b9e514a9eea8d7a3a980cb42"))
+		(1339000,     uint256S("0x000000016a3b0d888eaaf488fe99202db0cadabcace4f5606e13a8021e208beb"))
+		(1340000,     uint256S("0x0000000296642fe481256d81da12afbbfc867a6e56f7e88ee575376171a2eb2b"))
+		(1341000,     uint256S("0x000000047f7f7df7d25d0f93873e81f317b4c59970021ff99097b90662b34886"))
+		(1342000,     uint256S("0x00000003dee60bf850c721422ead96876a6479c0e249252cd7a0819756f214f0"))
+		(1343000,     uint256S("0x0000000479b89d6106880dd554c9f0839893680f6aaf1d17bdd353b5ff3b690d"))
+		(1344000,     uint256S("0x000000043e08866b7b3a2fb729934e38ed68a7158aae743dbd67e915cbbe25fa"))
+		(1345000,     uint256S("0x000000010d28f703987f82d284a6ab34eeb9c6cdf528cfd8ea9467377b48f978"))
+		(1346000,     uint256S("0x000000047577df762e1b9d1d36efd124d7c587e8a1b04992d012b48e1da03d1c"))
+		(1347000,     uint256S("0x000000050e60e964649507f0abaa9041969bc292e762179cc48e370d1e85109f"))
+		(1348000,     uint256S("0x0000000458aac55b9a6a7610abf79769ccbd21bccabe262d49313b637f360b7d"))
+		(1349000,     uint256S("0x00000001b36d5248c6632d6f353376991a3d7ce4b6730cd777042e8eef4c2050"))
+		(1350000,     uint256S("0x0000000040bdf5b1900a2d20f6fb7824f7f0ad2117a357ac212388bbe5238f40"))
+		(1351000,     uint256S("0x00000004a5e89800bd3e433dc1c3f36370b14523a219ccc513e9451c6354bb86"))
+		(1352000,     uint256S("0x000000025bda557523475832f119f8d5ebdd02f131c0004f529b0e6b16343a8e"))
+		(1353000,     uint256S("0x000000012e20cd31e7f6eda7d0e1d1777fde4a312a4c2ce6948d629e10b196ab"))
+		(1354000,     uint256S("0x0000000247ea366ee0719df82303d8e74aec615b2c006bb1b7d37c1d42366785"))
+		(1355000,     uint256S("0x0000000038f84260adf0773fa051af3467e0e4bf17adf73c4a9f8cc0ae0eb52f"))
+		(1356000,     uint256S("0x00000001b109fae9d09d98e829e273037a6209d29347485ffdee066f8f32d070"))
+		(1357000,     uint256S("0x00000002c9047e284ad3699ee0ccd158c141ad281fe7c78bcb8cae0012e2a7a5"))
+		(1358000,     uint256S("0x000000046e5f2a9d1b043840165ba292042ca4a6927f9451d8eb379e9f6b479f"))
+		(1359000,     uint256S("0x00000001fe154c692d9a7255fa9657023d213d3a2b0c6025bc2942452ff0bfa7"))
+		(1360000,     uint256S("0x00000002e0a212bc285eef4232f6805f95ef054582a43fd4b926ed23e75ec378"))
+		(1361000,     uint256S("0x0000000170ffed44b6503976cf15289556ec5ac785c63f371990dc1dcd01c0c1"))
+		(1362000,     uint256S("0x00000004b0a51f49dc942a4dac1c8cb7ebc3b5dc70c27488b950033543de9188"))
+		(1363000,     uint256S("0x00000002d39b32395989ff7065d238a9e6ca9643dde76f2c4fa090da64a9dfb0"))
+		(1364000,     uint256S("0x00000003fe2c6dafe4f7c45c2a07307864a85c649738a68fa9736990385aa1b6"))
+		(1365000,     uint256S("0x000000006a96f8887cb0b261ff9c0947ec9a35e388354a088012e0f3587a915d"))
+		(1366000,     uint256S("0x00000000b19f6e3ea6282cad35d25bd45f4a90799ca30de76ebfaa58360102b3"))
+		(1367000,     uint256S("0x00000005a4c7746ba3aa321bf6d0d939b65053fd7b8993541c4382d81b1df164"))
+		(1368000,     uint256S("0x00000005a2f3fac3d68493253cc28762ed0e7d8be207b72e9b3eba49b1301661"))
+		(1369000,     uint256S("0x00000001d963d93ec5f029920cd5ca0f8bfca9c85ce99f84585062d2c08edca3"))
+		(1370000,     uint256S("0x000000033c971fbcf50d26531667597acd4abf989473c10a7ecd23cd4546dc05"))
+		(1371000,     uint256S("0x00000002a277717fd9f5b05370e9c610662ffdb6f5489e96b96bc587dc22dc70"))
+		(1372000,     uint256S("0x00000001ef0f457f58b3523ec79d6ec265928ba5aaec6a5ee282242334883e15"))
+		(1373000,     uint256S("0x000000005911ed4432d3077e7254e35767ca8b00a674a1b047fd0dcc12bb1e6f"))
+		(1374000,     uint256S("0x0000000538363b8b3a25dce0a88990b96dff9787c2ec8189b70b13222008adfc"))
+		(1375000,     uint256S("0x000000021d15ac7123e2dc7ae2de2f045165911151b898063768eca1c27e31fa"))
+		(1376000,     uint256S("0x000000047928c3ff4ca5dec8dd99087df4770abd50469ce2bd3328346858373f"))
+		(1377000,     uint256S("0x0000000271c0b5532f810a9ffb563d09bf74b959fb1939c741dc140ec1874d09"))
+		(1378000,     uint256S("0x0000000048678a71baf3fdb3c5f905a78a75b6ffb02018b186693e87d8172eb4"))
+		(1379000,     uint256S("0x00000003460b8c58481e205f842eb3fda43f313a87a303f64a8f971268fba367"))
+		(1380000,     uint256S("0x000000023a6ce85edc04e5af620930477bea1aaf31ee262678968976717d176e"))
+		(1381000,     uint256S("0x0000000436b6c757c06b32648e510c4249b88928921f4d0bc39371600d0d0824"))
+		(1382000,     uint256S("0x00000001c7fd7b29c040c9c56d641ca219800d234e1eb8c640d86663de6cb335"))
+		(1383000,     uint256S("0x00000002b9cb3b2aca628572ae964b334efc22acc8ed50500d76e834cecb264f"))
+		(1384000,     uint256S("0x0000000550b1b189873d81707719eb1be9e2492f3897f59cf39aad447d12fe7d"))
+		(1385000,     uint256S("0x00000002c778e98b2871165ee43f441496ed6c50e6cd97bccc82448498ca3a2b"))
+		(1386000,     uint256S("0x000000037b6d4f8ed38297729f65b7dda39a0e297d0dff2b7ab11c31b784b5ce"))
+		(1387000,     uint256S("0x00000002aa3edc372bb3030959ee6eda0fc188b0837d8409c073553124e31ca3"))
+		(1388000,     uint256S("0x00000004c2ad445251b1faf327fcc6d4364d941e8b95377588d764845ce98e14"))
+		(1389000,     uint256S("0x00000003730f20a59c6c6bfb8ee168145113eab1db437a1683c782ad59a593cc"))
+		(1390000,     uint256S("0x00000001f4f78ddb8d92d00fea207be21bed937c632a70681a522f2b21257f30"))
+		(1391000,     uint256S("0x0000000252c913ab26a7d67b1ef969399edc40c0cb89c564a90bca7478511d06"))
+		(1392000,     uint256S("0x00000001a4fd677cd1510d2253223d62f3c1adc493ce88178663698aaae85ad4"))
+		(1393000,     uint256S("0x0000000326c759d56837a8ded29af2f0628c89ea018f45f44ccc27539cda123c"))
+		(1394000,     uint256S("0x00000006e8c60ec3bf6dbe664da6b86e29c0a6220706617b8bc024f313f600e5"))
+		(1395000,     uint256S("0x00000001a089c52a4740433d3395e9faedca3d80bba38a5c1d51bfa5d61a82a7"))
+		(1396000,     uint256S("0x00000009cb3a07fbfb926a75481ab04db3d1a108c73782272e184a66d55e5de9"))
+		(1397000,     uint256S("0x00000004aa55ca33c9e6fc43f9ddd0b0f32cade6a3c0dc120c7faf60d72903ff"))
+		(1398000,     uint256S("0x00000006091fd1a0d34b6dd29c590ba69569f910b96bcbc8434758c177f04022"))
+		(1399000,     uint256S("0x00000003c85038020294c7c58ea8a4bec845cf6494bdf63222b31f4748fea77a"))
+		(1400000,     uint256S("0x00000008d0941b9a5b394d19cff188a665cb8a57b89de8ad06f58fd08c6fcb8e"))
+		(1401000,     uint256S("0x000000013a5e8cd206aad4b6b1c256e567def77a371254f2b33096f315f401f9"))
+		(1402000,     uint256S("0x000000016587d0e9753056f74305dc05d818904248512bdc87dadc624e0be6dc"))
+		(1403000,     uint256S("0x000000015575532cb246eb7c065b955921104a246d4fef43f14009bf2da0d9eb"))
+		(1404000,     uint256S("0x000000055c93b66f7be3213b21f2f77eaf5e76c43060125d6cb3a91ca5ba8bd3"))
+		(1405000,     uint256S("0x00000003df2e2b33cbeeb78d320e273880df4d6deb0e661b576052ddcaccb11c"))
+		(1406000,     uint256S("0x00000003a9e7a1b897857b1df59931eae36855a66e39c4fe872c68440b8a77b6"))
+		(1407000,     uint256S("0x000000007f74d842e9a2923f32a0d64bdf3bfdf9bd742bcd689a8647b487de60"))
+		(1408000,     uint256S("0x000000004a021a23c0c31f2fcd82d757e20f2d7257880dec999061546c0309c9"))
+		(1409000,     uint256S("0x0000000078be552c979aaf660ef8b2d6a7f3d6878975f49f6d24c0c4d70fbe07"))
+		(1410000,     uint256S("0x000000071ffa758ba71f243c8b4106cdabaaa5ec0df9247af03f5dc9221b58b2"))
+		(1411000,     uint256S("0x00000007be4b7695ad2a5ef100899a22efad8b142ecbc8b93d5f8d553f9286d4"))
+		,(int64_t)  1688026050, // time of last checkpointed block
+		(int64_t) 0,      // total txs
+		(double)  2304        // txs in the last day before block 1411911

                };
                // 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/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@ -17,6 +17,7 @@ static const uint8_t chainparams_seed_main[] = {
    0x01,0x04,0x57,0xfb,0x4c,0x21,0x00,0x00, // 87.251.76.33
    0x01,0x04,0x89,0x4a,0x04,0xc6,0x00,0x00, // 137.74.4.198
    0x01,0x04,0x95,0x1c,0x66,0xdb,0x00,0x00, // 149.28.102.219
+    0x01,0x04,0x9b,0x8a,0xe4,0x44,0x00,0x00, // 155.138.228.68
    0x01,0x04,0x6b,0xae,0x46,0xfb,0x00,0x00, // 107.174.70.251
    0x04,0x20,0xef,0xad,0x0c,0x95,0x3e,0x61,0xee,0x69,0x57,0x67,0xdb,0x4f,0xb7,0x8d,0xc2,0x35,0x1c,0x6b,0x96,0xf4,0x1f,0x7a,0xb4,0x06,0x09,0x3a,0x64,0x33,0xf4,0x0b,0x2c,0x94,0x00,0x00, // 56wqzfj6mhxgsv3h3nh3pdocguogxfxud55libqjhjsdh5alfsko2iqd.onion
    0x04,0x20,0x3d,0x24,0x7a,0xec,0xfe,0x60,0x6e,0x3d,0x3d,0xf3,0x4f,0x35,0x12,0x29,0xdb,0x48,0x89,0x71,0x19,0xb9,0xee,0x6a,0xfd,0xb2,0x02,0xa7,0x99,0x89,0xbb,0x69,0x39,0xdb,0x00,0x00, // hushv3h6mbxd2pptj42reko3jcexcgnz5zvp3mqcu6myto3jhhn4yzyd.onion
--- a/src/clientversion.h
+++ b/src/clientversion.h
@ -30,7 +30,7 @@
 // Must be kept in sync with configure.ac , ugh!
 #define CLIENT_VERSION_MAJOR 3
 #define CLIENT_VERSION_MINOR 9
-#define CLIENT_VERSION_REVISION 3
+#define CLIENT_VERSION_REVISION 4
 #define CLIENT_VERSION_BUILD 50

 //! Set to true for release, false for prerelease or test build
--- 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)
@ -635,107 +540,6 @@ int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts)

 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
-{
-    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;
-    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 ||
-         ((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,7 +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_checkvout(int32_t vout,int32_t k,int32_t indallvouts);
 pthread_mutex_t hush_mutex;

--- 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);
        }
--- 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())
    {
@ -4999,7 +4988,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,
@ -5121,7 +5109,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) {
--- 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/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@ -1064,79 +1064,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/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)
 {
--- 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";
--- a/util/gen-linux-binary-release.sh
+++ b/util/gen-linux-binary-release.sh
@ -8,7 +8,8 @@ set -x
 #hardcode and uncomment if hushd is not running on this machine
 #VERSION=3.6.3
 VERSION=$(./src/hushd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g')
-FILE="hush-$VERSION-linux-amd64.tar"
+DIR="hush-$VERSION-linux-amd64"
+FILE="$DIR.tar"
 TIME=$(perl -e 'print time')

 if [ -d "build" ]
@ -17,14 +18,17 @@ then
    echo "Moved existing build/ dir to build.$TIME"
 fi
 mkdir build
-echo "Created new build/ dir"
-cp contrib/asmap/asmap.dat build/
-cp sapling*.params build/
+BUILD="build/$DIR"
+mkdir $BUILD
+echo "Created new build dir $BUILD"
+cp contrib/asmap/asmap.dat $BUILD
+cp sapling*.params $BUILD
 cd src
-cp hushd hush-cli hush-tx hush-smart-chain dragonx-cli dragonxd ../build
-cd ../build
+cp hushd hush-cli hush-tx hush-smart-chain dragonx-cli dragonxd ../$BUILD
+cd ../$BUILD
 strip hushd hush-cli hush-tx
-tar -f $FILE -c  *
+cd ..
+tar -f $FILE -c  hush-$VERSION-linux-amd64/*
 gzip -9 $FILE
 sha256sum *.gz
 du -sh *.gz