# code_items

name: EXCLUSIVE_LOCK_FUNCTION
lower_name_hint: excl
type:
CMutexLock(Mutex & mutexIn, const char * pszName, const char * pszFile, int nLine, bool fTry = false) 


name: EXCLUSIVE_LOCK_FUNCTION
lower_name_hint: excl
type:
CMutexLock(Mutex * pmutexIn, const char * pszName, const char * pszFile, int nLine, bool fTry = false) 


name: ThreadSafeMessageBox
lower_name_hint: thre
type:
boost::signals2::signal<bool(const std::string&message,const std::string&caption,unsigned int style),boost::signals2::last_value<bool>> 


name: ThreadSafeQuestion
lower_name_hint: thre
type:
boost::signals2::signal<bool(const std::string&message,const std::string&noninteractive_message,const std::string&caption,unsigned int style),boost::signals2::last_value<bool>> 


name: level
lower_name_hint: leve
type:
bool(int , bool ret, unsigned char chRejectCodeIn,std::string strRejectReasonIn, bool corruptionIn)


name: create_
lower_name_hint: crea
type:
char *(* )(void *, const char * const *key_array, const size_t *key_length_array, int num_keys,size_t *filter_length)


name: secp256k1_nonce_function_t
lower_name_hint: secp
type:
int(* )(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int attempt, const void *data)


name: CallRPC
type: 
lower_name_hint: call
param_default_value:
("fundrawtransaction 01000000000180969800000000001976a91450ce0a4b0ee0ddeb633da85199728b940ac3fe9488ac00000000")


name: NotifyAddressBookChanged
lower_name_hint: noti
type:
boost::signals2::signal<void(CWallet*wallet,const CTxDestination&address,const std::string&label,bool isMine,const std::string&purpose,ChangeType status)> 


# assoc_text

text:


text:
= {{OperationStatus::READY,"queued"},{OperationStatus::EXECUTING,"executing"},{OperationStatus::CANCELLED,"cancelled"},{OperationStatus::FAILED,"failed"},{OperationStatus::SUCCESS,"success"}}


text:
= BLOCK_VALID_HEADER|BLOCK_VALID_TREE|BLOCK_VALID_TRANSACTIONS|BLOCK_VALID_CHAIN|BLOCK_VALID_SCRIPTS


text:
BOOST_PP_IF( BOOST_PP_LESS(build, 25), RENDER_BETA_STRING(BOOST_PP_ADD(build, 1)), BOOST_PP_IF( BOOST_PP_LESS(build, 50), RENDER_RC_STRING(BOOST_PP_SUB(build, 24)), BOOST_PP_IF( BOOST_PP_EQUAL(build, 50), "", RENDER_DEV_STRING(BOOST_PP_SUB(build, 50)))))


text:
"v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(rev) RENDER_BUILD(build) "-" DO_STRINGIZE(suffix)


text:
BUILD_DESC_WITH_SUFFIX(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD, BUILD_SUFFIX)


text:
BUILD_DESC_FROM_COMMIT(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD, GIT_COMMIT_ID)


text:
BUILD_DESC_FROM_UNKNOWN(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD)


text:
= 1000000*CLIENT_VERSION_MAJOR+10000*CLIENT_VERSION_MINOR+100*CLIENT_VERSION_REVISION+1*CLIENT_VERSION_BUILD


text:
= {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x40}


text:
= {0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x5D,0x57,0x6E,0x73,0x57,0xA4,0x50,0x1D,0xDF,0xE9,0x2F,0x46,0x68,0x1B,0x20,0xA0}


text:
= boost::bind(&PartitionCheck,&IsInitialBlockDownload,boost::ref(cs_main),boost::cref(pindexBestHeader),nPowTargetSpacing)


text:
= {{"ALL",SIGHASH_ALL},{"NONE",SIGHASH_NONE},{"SINGLE",SIGHASH_SINGLE},{"ALL|ANYONECANPAY",SIGHASH_ALL|SIGHASH_ANYONECANPAY},{"NONE|ANYONECANPAY",SIGHASH_NONE|SIGHASH_ANYONECANPAY},{"SINGLE|ANYONECANPAY",SIGHASH_SINGLE|SIGHASH_ANYONECANPAY},}


text:
output[s+0] |= input[i] & 0xff; output[s+1] = (input[i] >> 8) & 0xff; output[s+2] = (input[i] >> 16) & 0xff; output[s+3] = (input[i] >> 24) & 0xff;


text:
(" <- opret, MINER deposits.%d (%s) vouts.%d %.8f opretlen.%d\n",tokomodo,ASSETCHAINS_SYMBOL,numvouts,dstr(PENDING_KOMODO_TX),opretlen)


text:
= {"78cb4e21245c26b015b888b14c4f5096e18137d2741a6de9734d62b07014dfca","00697be658e05561febdee1aafe368b821ca33fbb89b7027365e3d77b5dfede5","e909465788b32047c472d73e882d79a92b0d550f90be008f76e1edaee6d742ea","f56c6873748a327d0b92b8108f8ec8505a2843a541b1926022883678fb24f9dc","abf08be07d8f5b3a433ddcca7ef539e79a3571632efd6d0294ec0492442a0204","3b854b996cc982fba8c06e76cf507ae7eed52ab92663f4c0d7d10b3ed879c3b0","fa9e474c2cda3cb4127881a40eb3f682feaba3f3328307d518589024a6032cc4","ca746fa13e0113c4c0969937ea2c66de036d20274efad4ce114f6b699f1bc0f3","43ce88438de4973f21b1388ffe66e68fda592da38c6ef939be10bb1b86387041","0aeb748de82f209cd5ff7d3a06f65543904c4c17387c9d87c65fd44b14ad8f8c","bbd3a3d9b14730991e1066bd7c626ca270acac4127131afe25f877a5a886eb25","fa9943525f2e6c32cbc243294b08187e314d83a2870830180380c3c12a9fd33c","a01671c8775328a41304e31a6693bbd35e9acbab28ab117f729eaba9cb769461","2ef49d2d27946ad7c5d5e4ab5c089696762ff04e855f8ab48e83bdf0cc68726d","c85dcffb16d5a45bd239021ad33443414d60224760f11d535ae2063e5709efee","c4ea1462c207547cd6fb6a4155ca6d042b22170d29801a465db5c09fec55b19d","305dc96d8bc23a69d3db955e03a6a87c1832673470c32fe25473a46cc473c7d1",}


text:
= {{"jl777_testA","03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828"},{"jl777_testB","02ebfc784a4ba768aad88d44d1045d240d47b26e248cafaf1c5169a42d7a61d344"},{"pondsea_SH","02209073bc0943451498de57f802650311b1f12aa6deffcd893da198a544c04f36"},{"crackers_EU","0340c66cf2c41c41efb420af57867baa765e8468c12aa996bfd816e1e07e410728"},{"pondsea_EU","0225aa6f6f19e543180b31153d9e6d55d41bc7ec2ba191fd29f19a2f973544e29d"},{"locomb_EU","025c6d26649b9d397e63323d96db42a9d3caad82e1d6076970efe5056c00c0779b"},{"fullmoon_AE","0204a908350b8142698fdb6fabefc97fe0e04f537adc7522ba7a1e8f3bec003d4a"},{"movecrypto_EU","021ab53bc6cf2c46b8a5456759f9d608966eff87384c2b52c0ac4cc8dd51e9cc42"},{"badass_EU","0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e"},{"crackers_NA","029e1c01131974f4cd3f564cc0c00eb87a0f9721043fbc1ca60f9bd0a1f73f64a1"},{"proto_EU","03681ffdf17c8f4f0008cefb7fa0779c5e888339cdf932f0974483787a4d6747c1"},{"jeezy_EU","023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6"},{"farl4web_EU","035caa40684ace968677dca3f09098aa02b70e533da32390a7654c626e0cf908e1"},{"nxtswe_EU","032fb104e5eaa704a38a52c126af8f67e870d70f82977e5b2f093d5c1c21ae5899"},{"traderbill_EU","03196e8de3e2e5d872f31d79d6a859c8704a2198baf0af9c7b21e29656a7eb455f"},{"vanbreuk_EU","024f3cad7601d2399c131fd070e797d9cd8533868685ddbe515daa53c2e26004c3"},{"titomane_EU","03517fcac101fed480ae4f2caf775560065957930d8c1facc83e30077e45bdd199"},{"supernet_AE","029d93ef78197dc93892d2a30e5a54865f41e0ca3ab7eb8e3dcbc59c8756b6e355"},{"supernet_EU","02061c6278b91fd4ac5cab4401100ffa3b2d5a277e8f71db23401cc071b3665546"},{"supernet_NA","033c073366152b6b01535e15dd966a3a8039169584d06e27d92a69889b720d44e1"},{"yassin_EU","033fb7231bb66484081952890d9a03f91164fb27d392d9152ec41336b71b15fbd0"},{"durerus_EU","02bcbd287670bdca2c31e5d50130adb5dea1b53198f18abeec7211825f47485d57"},{"badass_SH","026b49dd3923b78a592c1b475f208e23698d3f085c4c3b4906a59faf659fd9530b"},{"badass_NA","02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7"},{"pondsea_NA","031bcfdbb62268e2ff8dfffeb9ddff7fe95fca46778c77eebff9c3829dfa1bb411"},{"rnr_EU","0287aa4b73988ba26cf6565d815786caf0d2c4af704d7883d163ee89cd9977edec"},{"crackers_SH","02313d72f9a16055737e14cfc528dcd5d0ef094cfce23d0348fe974b6b1a32e5f0"},{"grewal_SH","03212a73f5d38a675ee3cdc6e82542a96c38c3d1c79d25a1ed2e42fcf6a8be4e68"},{"polycryptoblock_NA","02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622"},{"titomane_NA","0387046d9745414fb58a0fa3599078af5073e10347e4657ef7259a99cb4f10ad47"},{"titomane_AE","03cda6ca5c2d02db201488a54a548dbfc10533bdc275d5ea11928e8d6ab33c2185"},{"kolo_EU","03f5c08dadffa0ffcafb8dd7ffc38c22887bd02702a6c9ac3440deddcf2837692b"},{"artik_NA","0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842"},{"eclips_EU","0339369c1f5a2028d44be7be6f8ec3b907fdec814f87d2dead97cab4edb71a42e9"},{"titomane_SH","035f49d7a308dd9a209e894321f010d21b7793461b0c89d6d9231a3fe5f68d9960"},}


text:
= {{"0_jl777_testA","03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828"},{"0_jl777_testB","02ebfc784a4ba768aad88d44d1045d240d47b26e248cafaf1c5169a42d7a61d344"},{"0_kolo_testA","0287aa4b73988ba26cf6565d815786caf0d2c4af704d7883d163ee89cd9977edec"},{"artik_AR","029acf1dcd9f5ff9c455f8bb717d4ae0c703e089d16cf8424619c491dff5994c90"},{"artik_EU","03f54b2c24f82632e3cdebe4568ba0acf487a80f8a89779173cdb78f74514847ce"},{"artik_NA","0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842"},{"artik_SH","02bdd8840a34486f38305f311c0e2ae73e84046f6e9c3dd3571e32e58339d20937"},{"badass_EU","0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e"},{"badass_NA","02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7"},{"badass_SH","026b49dd3923b78a592c1b475f208e23698d3f085c4c3b4906a59faf659fd9530b"},{"crackers_EU","03bc819982d3c6feb801ec3b720425b017d9b6ee9a40746b84422cbbf929dc73c3"},{"crackers_NA","03205049103113d48c7c7af811b4c8f194dafc43a50d5313e61a22900fc1805b45"},{"crackers_SH","02be28310e6312d1dd44651fd96f6a44ccc269a321f907502aae81d246fabdb03e"},{"durerus_EU","02bcbd287670bdca2c31e5d50130adb5dea1b53198f18abeec7211825f47485d57"},{"etszombi_AR","031c79168d15edabf17d9ec99531ea9baa20039d0cdc14d9525863b83341b210e9"},{"etszombi_EU","0281b1ad28d238a2b217e0af123ce020b79e91b9b10ad65a7917216eda6fe64bf7"},{"etszombi_SH","025d7a193c0757f7437fad3431f027e7b5ed6c925b77daba52a8755d24bf682dde"},{"farl4web_EU","0300ecf9121cccf14cf9423e2adb5d98ce0c4e251721fa345dec2e03abeffbab3f"},{"farl4web_SH","0396bb5ed3c57aa1221d7775ae0ff751e4c7dc9be220d0917fa8bbdf670586c030"},{"fullmoon_AR","0254b1d64840ce9ff6bec9dd10e33beb92af5f7cee628f999cb6bc0fea833347cc"},{"fullmoon_NA","031fb362323b06e165231c887836a8faadb96eda88a79ca434e28b3520b47d235b"},{"fullmoon_SH","030e12b42ec33a80e12e570b6c8274ce664565b5c3da106859e96a7208b93afd0d"},{"grewal_NA","03adc0834c203d172bce814df7c7a5e13dc603105e6b0adabc942d0421aefd2132"},{"grewal_SH","03212a73f5d38a675ee3cdc6e82542a96c38c3d1c79d25a1ed2e42fcf6a8be4e68"},{"indenodes_AR","02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147"},{"indenodes_EU","0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c"},{"indenodes_NA","02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988"},{"indenodes_SH","0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e"},{"jeezy_EU","023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6"},{"jsgalt_NA","027b3fb6fede798cd17c30dbfb7baf9332b3f8b1c7c513f443070874c410232446"},{"karasugoi_NA","02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982"},{"kashifali_EU","033777c52a0190f261c6f66bd0e2bb299d30f012dcb8bfff384103211edb8bb207"},{"kolo_AR","03016d19344c45341e023b72f9fb6e6152fdcfe105f3b4f50b82a4790ff54e9dc6"},{"kolo_SH","02aa24064500756d9b0959b44d5325f2391d8e95c6127e109184937152c384e185"},{"metaphilibert_AR","02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6"},{"movecrypto_AR","022783d94518e4dc77cbdf1a97915b29f427d7bc15ea867900a76665d3112be6f3"},{"movecrypto_EU","021ab53bc6cf2c46b8a5456759f9d608966eff87384c2b52c0ac4cc8dd51e9cc42"},{"movecrypto_NA","02efb12f4d78f44b0542d1c60146738e4d5506d27ec98a469142c5c84b29de0a80"},{"movecrypto_SH","031f9739a3ebd6037a967ce1582cde66e79ea9a0551c54731c59c6b80f635bc859"},{"muros_AR","022d77402fd7179335da39479c829be73428b0ef33fb360a4de6890f37c2aa005e"},{"noashh_AR","029d93ef78197dc93892d2a30e5a54865f41e0ca3ab7eb8e3dcbc59c8756b6e355"},{"noashh_EU","02061c6278b91fd4ac5cab4401100ffa3b2d5a277e8f71db23401cc071b3665546"},{"noashh_NA","033c073366152b6b01535e15dd966a3a8039169584d06e27d92a69889b720d44e1"},{"nxtswe_EU","032fb104e5eaa704a38a52c126af8f67e870d70f82977e5b2f093d5c1c21ae5899"},{"polycryptoblog_NA","02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622"},{"pondsea_AR","032e1c213787312099158f2d74a89e8240a991d162d4ce8017d8504d1d7004f735"},{"pondsea_EU","0225aa6f6f19e543180b31153d9e6d55d41bc7ec2ba191fd29f19a2f973544e29d"},{"pondsea_NA","031bcfdbb62268e2ff8dfffeb9ddff7fe95fca46778c77eebff9c3829dfa1bb411"},{"pondsea_SH","02209073bc0943451498de57f802650311b1f12aa6deffcd893da198a544c04f36"},{"popcornbag_AR","02761f106fb34fbfc5ddcc0c0aa831ed98e462a908550b280a1f7bd32c060c6fa3"},{"popcornbag_NA","03c6085c7fdfff70988fda9b197371f1caf8397f1729a844790e421ee07b3a93e8"},{"ptytrader_NA","0328c61467148b207400b23875234f8a825cce65b9c4c9b664f47410b8b8e3c222"},{"ptytrader_SH","0250c93c492d8d5a6b565b90c22bee07c2d8701d6118c6267e99a4efd3c7748fa4"},{"rnr_AR","029bdb08f931c0e98c2c4ba4ef45c8e33a34168cb2e6bf953cef335c359d77bfcd"},{"rnr_EU","03f5c08dadffa0ffcafb8dd7ffc38c22887bd02702a6c9ac3440deddcf2837692b"},{"rnr_NA","02e17c5f8c3c80f584ed343b8dcfa6d710dfef0889ec1e7728ce45ce559347c58c"},{"rnr_SH","037536fb9bdfed10251f71543fb42679e7c52308bcd12146b2568b9a818d8b8377"},{"titomane_AR","03cda6ca5c2d02db201488a54a548dbfc10533bdc275d5ea11928e8d6ab33c2185"},{"titomane_EU","02e41feded94f0cc59f55f82f3c2c005d41da024e9a805b41105207ef89aa4bfbd"},{"titomane_SH","035f49d7a308dd9a209e894321f010d21b7793461b0c89d6d9231a3fe5f68d9960"},{"vanbreuk_EU","024f3cad7601d2399c131fd070e797d9cd8533868685ddbe515daa53c2e26004c3"},{"xrobesx_NA","03f0cc6d142d14a40937f12dbd99dbd9021328f45759e26f1877f2a838876709e1"},{"xxspot1_XX","02ef445a392fcaf3ad4176a5da7f43580e8056594e003eba6559a713711a27f955"},{"xxspot2_XX","03d85b221ea72ebcd25373e7961f4983d12add66a92f899deaf07bab1d8b6f5573"}}


text:
= {3317900000000,6991604000000,667780000000000,1616854000000,331000000000,861909000000,584629000000,46530000000,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}


text:
= {MIND,MIND,100*MIND,MIND,MIND,MIND,MIND,MIND,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,10*MIND,}


text:
= {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}


text:
= {962714545,962506087,962158759,961672710,961048151,960285354,959384649,958346426,957171134,955859283,954411438,952828225,951110328,949258485,947273493,945156207,942907532,940528434,938019929,935383089,932619036,929728945,926714044,923575608,920314964,916933485,913432593,909813756,906078486,902228342,898264923,894189872,890004874,885711650,881311964,876807614,872200436,867492300,862685110,857780804,852781347,847688737,842505000,837232189,831872382,826427681,820900212,815292123,809605581,803842772,798005901,792097186,786118864,780073180,773962395,767788778,761554609,755262175,748913768,742511686,736058231,729555707,723006417,716412665,709776755,703100984,696387648,689639036,682857428,676045100,669204315,662337327,655446378,648533696,641601496,634651978,627687325,620709702,613721256,606724115,599720386,592712154,585701482,578690411,571680955,564675105,557674825,550682053,543698699,536726645,529767743,522823816,515896658,508988029,502099660,495233249,488390461,481572928,474782249,468019988,461287675,454586804,447918836,441285195,434687268,428126409,421603932,415121117,408679208,402279408,395922888,389610779,383344175,377124134,370951677,364827785,358753406,352729449,346756785,340836251,334968645,329154729,323395230,317690838,312042206,306449955,300914667,295436891,290017141,284655897,279353604,274110676,268927490,263804394,258741701,253739694,248798623,243918709,239100140,234343077,229647649,225013957,220442073,215932043,211483883,207097585,202773112,198510404,194309373,190169909,186091877,182075118,178119452,174224676,170390565,166616873,162903335,159249664,155655556,152120688,148644718,145227287,141868021,138566528,135322401,132135218,129004542,125929924,122910901,119946997,117037723,114182582,111381062,108632643,105936795,103292978,100700645,98159238,95668194,93226942,90834903,88491495,86196126,83948203,81747126,79592292,77483092,75418916,73399150,71423178,69490383,67600142,65751837,63944844,62178541,60452305,58765515,57117547,55507781,53935597,52400377,50901505,49438366,48010349,46616844,45257246,43930951,42637360,41375878,40145912,38946876,37778185,36639262,35529533,34448428,33395384,32369842,31371249,30399057,29452725,28531717,27635503,26763558,25915365,25090413,24288196,23508216,22749980,22013003,21296806,20600917,19924870,19268206,18630475,18011231,17410035,16826458,16260073,15710466,15177224,14659944,14158231,13671694,13199950,12742625,12299348,11869759,11453500,11050225,10659590,10281262,9914910,9560213,9216856,8884529,8562931,8251764,7950739,7659571,7377984,7105706,6842471,6588020,6342099,6104460,5874861,5653066,5438844,5231969,5032221,4839386,4653254,4473620,4300287,4133059,3971747,3816167,3666139,3521488,3382043,3247640,3118115,2993313,2873079,2757266,2645728,2538325,2434919,2335380,2239575,2147382,2058677,1973342,1891262,1812325,1736424,1663453,1593311,1525898,1461118,1398879,1339091,1281666,1226519,1173569,1122736,1073944,1027117,982185,939076,897725,858065,820033,783568,748612,715108,682999,652233,622759,594527,567488,541597,516808,493079,470368,448635,427841,407948,388921,370725,353326,336692,320792,305596,291075,277202,263950,251292,239204,227663,216646,206130,196094,186517,177381,168667,160356,152430,144874,137671,130806,124264,118031,112093,106437,101050,95921,91039,86391,81968,77759,73755,69945,66322,62877,59602,56488,53528,50716,48043,45505,43093,40803,38629,36564,34604,32745,30980,29305,27717,26211,24782,23428,22144,20927,19774,18681,17646,16665,15737,14857,14025,13237,12491,11786,11118,10487,9890,9325,8791,8287,7810,7359,6933,6531,6151,5792,5453,5133,4831,4547,4278,4024,3785,3560,3347,3147,2958,2779,2612,2454,2305,2164,2032,1908,1791,1681,1577,1480,1388,1302,1221,1145,1073,1006,942,883,827,775,725,679,636,595,557,521,487,456,426,399,373,348,325,304,284,265,248,231,216,202,188,175,164,153,142,133,124,115,107,100,93,87,81,75,70,65,61,56,53,49,45,42,39,36,34,31,29,27,25,23,22,20,19,17,16,15,14,13,12,11,10,9,9,8,7,7,6,6,5,5,5,4,4}


text:
{ (y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); (y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); }


text:
{ x = (uint32_t)(((uint64_t)((y)[3] & 255)<<24) | ((uint32_t)((y)[2] & 255)<<16) | ((uint32_t)((y)[1] & 255)<<8) | ((uint32_t)((y)[0] & 255))); }


text:
{ (y)[7] = (uint8_t)(((x)>>56)&255); (y)[6] = (uint8_t)(((x)>>48)&255); (y)[5] = (uint8_t)(((x)>>40)&255); (y)[4] = (uint8_t)(((x)>>32)&255); (y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); (y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); }


text:
{ x = (((uint64_t)((y)[7] & 255))<<56)|(((uint64_t)((y)[6] & 255))<<48)| (((uint64_t)((y)[5] & 255))<<40)|(((uint64_t)((y)[4] & 255))<<32)| (((uint64_t)((y)[3] & 255))<<24)|(((uint64_t)((y)[2] & 255))<<16)| (((uint64_t)((y)[1] & 255))<<8)|(((uint64_t)((y)[0] & 255))); }


text:
{ (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255); (y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); }


text:
{ x = (uint32_t)(((uint64_t)((y)[0] & 255)<<24) | ((uint32_t)((y)[1] & 255)<<16) | ((uint32_t)((y)[2] & 255)<<8) | ((uint32_t)((y)[3] & 255))); }


text:
{ (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); }


text:
{ x = (((uint64_t)((y)[0] & 255))<<56)|(((uint64_t)((y)[1] & 255))<<48) | (((uint64_t)((y)[2] & 255))<<40)|(((uint64_t)((y)[3] & 255))<<32) | (((uint64_t)((y)[4] & 255))<<24)|(((uint64_t)((y)[5] & 255))<<16) | (((uint64_t)((y)[6] & 255))<<8)|(((uint64_t)((y)[7] & 255))); }


text:
( ((((uint32_t)(x)&0xFFFFFFFFUL)>>(uint32_t)((y)&31)) | ((uint32_t)(x)<<(uint32_t)(32-((y)&31)))) & 0xFFFFFFFFUL)


text:
( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)


text:
int func_name (struct rmd160_vstate * md, const unsigned char *in, unsigned long inlen) { unsigned long n; int err; if (md->curlen > sizeof(md->buf)) { return -1; } while (inlen > 0) { if (md->curlen == 0 && inlen >= block_size) { if ((err = compress_name (md, (unsigned char *)in)) != 0) { return err; } md->length += block_size * 8; in += block_size; inlen -= block_size; } else { n = MIN(inlen, (block_size - md->curlen)); memcpy(md->buf + md->curlen, in, (size_t)n); md->curlen += n; in += n; inlen -= n; if (md->curlen == block_size) { if ((err = compress_name (md, md->buf)) != 0) { return err; } md->length += 8*block_size; md->curlen = 0; } } } return 0; }


text:
= {0x00000000,0x77073096,0xee0e612c,0x990951ba,0x076dc419,0x706af48f,0xe963a535,0x9e6495a3,0x0edb8832,0x79dcb8a4,0xe0d5e91e,0x97d2d988,0x09b64c2b,0x7eb17cbd,0xe7b82d07,0x90bf1d91,0x1db71064,0x6ab020f2,0xf3b97148,0x84be41de,0x1adad47d,0x6ddde4eb,0xf4d4b551,0x83d385c7,0x136c9856,0x646ba8c0,0xfd62f97a,0x8a65c9ec,0x14015c4f,0x63066cd9,0xfa0f3d63,0x8d080df5,0x3b6e20c8,0x4c69105e,0xd56041e4,0xa2677172,0x3c03e4d1,0x4b04d447,0xd20d85fd,0xa50ab56b,0x35b5a8fa,0x42b2986c,0xdbbbc9d6,0xacbcf940,0x32d86ce3,0x45df5c75,0xdcd60dcf,0xabd13d59,0x26d930ac,0x51de003a,0xc8d75180,0xbfd06116,0x21b4f4b5,0x56b3c423,0xcfba9599,0xb8bda50f,0x2802b89e,0x5f058808,0xc60cd9b2,0xb10be924,0x2f6f7c87,0x58684c11,0xc1611dab,0xb6662d3d,0x76dc4190,0x01db7106,0x98d220bc,0xefd5102a,0x71b18589,0x06b6b51f,0x9fbfe4a5,0xe8b8d433,0x7807c9a2,0x0f00f934,0x9609a88e,0xe10e9818,0x7f6a0dbb,0x086d3d2d,0x91646c97,0xe6635c01,0x6b6b51f4,0x1c6c6162,0x856530d8,0xf262004e,0x6c0695ed,0x1b01a57b,0x8208f4c1,0xf50fc457,0x65b0d9c6,0x12b7e950,0x8bbeb8ea,0xfcb9887c,0x62dd1ddf,0x15da2d49,0x8cd37cf3,0xfbd44c65,0x4db26158,0x3ab551ce,0xa3bc0074,0xd4bb30e2,0x4adfa541,0x3dd895d7,0xa4d1c46d,0xd3d6f4fb,0x4369e96a,0x346ed9fc,0xad678846,0xda60b8d0,0x44042d73,0x33031de5,0xaa0a4c5f,0xdd0d7cc9,0x5005713c,0x270241aa,0xbe0b1010,0xc90c2086,0x5768b525,0x206f85b3,0xb966d409,0xce61e49f,0x5edef90e,0x29d9c998,0xb0d09822,0xc7d7a8b4,0x59b33d17,0x2eb40d81,0xb7bd5c3b,0xc0ba6cad,0xedb88320,0x9abfb3b6,0x03b6e20c,0x74b1d29a,0xead54739,0x9dd277af,0x04db2615,0x73dc1683,0xe3630b12,0x94643b84,0x0d6d6a3e,0x7a6a5aa8,0xe40ecf0b,0x9309ff9d,0x0a00ae27,0x7d079eb1,0xf00f9344,0x8708a3d2,0x1e01f268,0x6906c2fe,0xf762575d,0x806567cb,0x196c3671,0x6e6b06e7,0xfed41b76,0x89d32be0,0x10da7a5a,0x67dd4acc,0xf9b9df6f,0x8ebeeff9,0x17b7be43,0x60b08ed5,0xd6d6a3e8,0xa1d1937e,0x38d8c2c4,0x4fdff252,0xd1bb67f1,0xa6bc5767,0x3fb506dd,0x48b2364b,0xd80d2bda,0xaf0a1b4c,0x36034af6,0x41047a60,0xdf60efc3,0xa867df55,0x316e8eef,0x4669be79,0xcb61b38c,0xbc66831a,0x256fd2a0,0x5268e236,0xcc0c7795,0xbb0b4703,0x220216b9,0x5505262f,0xc5ba3bbe,0xb2bd0b28,0x2bb45a92,0x5cb36a04,0xc2d7ffa7,0xb5d0cf31,0x2cd99e8b,0x5bdeae1d,0x9b64c2b0,0xec63f226,0x756aa39c,0x026d930a,0x9c0906a9,0xeb0e363f,0x72076785,0x05005713,0x95bf4a82,0xe2b87a14,0x7bb12bae,0x0cb61b38,0x92d28e9b,0xe5d5be0d,0x7cdcefb7,0x0bdbdf21,0x86d3d2d4,0xf1d4e242,0x68ddb3f8,0x1fda836e,0x81be16cd,0xf6b9265b,0x6fb077e1,0x18b74777,0x88085ae6,0xff0f6a70,0x66063bca,0x11010b5c,0x8f659eff,0xf862ae69,0x616bffd3,0x166ccf45,0xa00ae278,0xd70dd2ee,0x4e048354,0x3903b3c2,0xa7672661,0xd06016f7,0x4969474d,0x3e6e77db,0xaed16a4a,0xd9d65adc,0x40df0b66,0x37d83bf0,0xa9bcae53,0xdebb9ec5,0x47b2cf7f,0x30b5ffe9,0xbdbdf21c,0xcabac28a,0x53b39330,0x24b4a3a6,0xbad03605,0xcdd70693,0x54de5729,0x23d967bf,0xb3667a2e,0xc4614ab8,0x5d681b02,0x2a6f2b94,0xb40bbe37,0xc30c8ea1,0x5a05df1b,0x2d02ef8d}


text:
= {"USD","EUR","JPY","GBP","AUD","CAD","CHF","NZD","CNY","RUB","MXN","BRL","INR","HKD","TRY","ZAR","PLN","NOK","SEK","DKK","CZK","HUF","ILS","KRW","MYR","PHP","RON","SGD","THB","BGN","IDR","HRK","KMD"}


text:


text:
= {(char*)"mnzd",(char*)"mnz-cli",(char*)"mnzd.exe",(char*)"mnz-cli.exe",(char*)"btchd",(char*)"btch-cli",(char*)"btchd.exe",(char*)"btch-cli.exe"}


text:
= {(char*)"MNZ",(char*)"MNZ",(char*)"MNZ",(char*)"MNZ",(char*)"BTCH",(char*)"BTCH",(char*)"BTCH",(char*)"BTCH"}


text:
("bench","      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs]\n",(unsigned)block.vtx.size(),0.001*(nTime1-nTimeStart),0.001*(nTime1-nTimeStart)/block.vtx.size(),nInputs<=1?0:0.001*(nTime1-nTimeStart)/(nInputs-1),nTimeConnect*0.000001)


text:
("bench","    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs]\n",nInputs-1,0.001*(nTime2-nTimeStart),nInputs<=1?0:0.001*(nTime2-nTimeStart)/(nInputs-1),nTimeVerify*0.000001)


text:
("bench","  - Connect postprocess: %.2fms [%.2fs]\n",(nTime6-nTime5)*0.001,nTimePostConnect*0.000001)


text:
("%s: hashBestChain=%s height=%d date=%s progress=%f\n",__func__,chainActive.Tip()->GetBlockHash().ToString(),chainActive.Height(),DateTimeStrFormat("%Y-%m-%d %H:%M:%S",chainActive.Tip()->GetBlockTime()),Checkpoints::GuessVerificationProgress(chainparams.Checkpoints(),chainActive.Tip()))


text:
("net","getblocks %d to %s limit %d from peer=%d\n",(pindex?pindex->nHeight:-1),hashStop.IsNull()?"end":hashStop.ToString(),nLimit,pfrom->id)


text:
("net","getheaders %d to %s from peer=%d\n",(pindex?pindex->nHeight:-1),hashStop.ToString(),pfrom->id)


text:
(stderr,"you can ignore redundant getheaders from peer.%d %d prev.%d\n",(int32_t)pfrom->id,(int32_t)(pindex?pindex->nHeight:-1),pfrom->lasthdrsreq)


text:
("mempool","AcceptToMemoryPool: peer=%d %s: accepted %s (poolsz %u)\n",pfrom->id,pfrom->cleanSubVer,tx.GetHash().ToString(),mempool.mapTx.size())


text:
("reject",strCommand,state.GetRejectCode(),state.GetRejectReason().substr(0,MAX_REJECT_MESSAGE_LENGTH),inv.hash)


text:
("net","more getheaders (%d) to end to peer=%d (startheight:%d)\n",pindexLast->nHeight,pfrom->id,pfrom->nStartingHeight)


text:
("net","initial getheaders (%d) to peer=%d (startheight:%d)\n",pindexStart->nHeight,pto->id,pto->nStartingHeight)


text:
((CBlockHeader::HEADER_SIZE + equihash_solution_size(N, K))*MAX_HEADERS_RESULTS < MAX_PROTOCOL_MESSAGE_LENGTH-1000)


text:
= "              [0;34;40m            [0m                                                      \n" "          [0;34;40m                    [0m                                                  \n" "       [0;34;40m      [0;31;40m:8[0;33;5;40;100m8[0;1;30;90;43mSX@888@@X[0;31;5;40;100m8[0;31;40m:[0;34;40m      [0m              [0;31;5;41;101m8;     %[0;1;31;91;41mX[0m        [0;1;31;91;41mX[0;31;5;41;101m%     ;8[0m       \n" "     [0;34;40m     [0;31;40m%[0;1;30;90;43m%X[0;1;33;93;43mt[0;33;5;43;103m%tt%[0;1;30;90;43mSSSS[0;33;5;43;103mS:[0;37;5;43;103mXXX[0;1;33;93;43mt[0;1;30;90;43m@[0;31;40m@[0;34;40m     [0m         [0;1;31;91;41mX[0;31;5;41;101m            :[0;1;31;91;41m:[0m  [0;1;31;91;41m:[0;31;5;41;101m:            [0;1;31;91;41mX[0m    \n" "   [0;34;40m     [0;31;40m@[0;1;30;90;43mS[0;1;33;93;43m;;tt%%[0;33;5;43;103m%[0;1;33;93;43mt[0;34;40m    [0;1;33;93;43m;[0;33;5;43;103m;::[0;37;5;43;103mXXXX[0;37;43mS[0;31;5;40;100mX[0;34;40m     [0m      [0;31;5;41;101m%               SS               %[0m   \n" "  [0;34;40m    [0;31;40m.[0;1;30;90;43mt[0;1;33;93;43m:::;;[0;1;30;90;43m%[0;31;40m8888[0;34;40m    [0;31;40m8[0;30;41m8888[0;1;33;93;43mt[0;37;5;43;103mXXXX[0;1;30;90;43m8[0;31;40m;[0;34;40m    [0m    [0;1;31;91;41mS[0;31;5;41;101m                                  [0;1;31;91;41mS[0m  \n" " [0;34;40m    [0;31;40m.[0;1;30;90;43m%[0;1;33;93;43m...:::[0;31;40m8[0;34;40m             [0;1;30;90;43m8[0;33;5;43;103m::[0;37;5;43;103mXXX[0;1;33;93;43m%[0;31;40m;[0;34;40m    [0m   [0;31;5;41;101mX                                  X[0m  \n" " [0;34;40m    [0;31;43m8[0;1;31;91;43m888[0;1;33;93;43m...:[0;1;30;90;43mt[0;1;30;90;41m888888[0;31;40mX[0;34;40m     [0;33;5;40;100m8[0;33;5;43;103mt;;::[0;37;5;43;103mXX[0;1;30;90;43m8[0;31;40m [0;34;40m   [0m   [0;31;5;41;101m8                                  8[0m  \n" "[0;34;40m    [0;31;40m%[0;1;31;91;43m888888[0;1;33;93;43m...:::;:[0;1;30;90;41m8[0;31;40m [0;34;40m   [0;31;40m:[0;1;30;90;43mX[0;33;5;43;103mttt;;;::[0;37;5;43;103mX[0;31;5;40;100m@[0;34;40m    [0m   [0;31;5;41;101m                                  [0m   \n" "[0;34;40m    [0;1;30;90;41m8[0;1;31;91;43m88888888[0;1;33;93;43m...:[0;1;30;90;43mS[0;31;40mt[0;34;40m    [0;1;30;90;41m8[0;1;33;93;43m:%[0;33;5;43;103m%tttt;;;:[0;1;30;90;43mX[0;34;40m    [0m   [0;31;5;41;101mX                                X[0m   \n" "[0;34;40m    [0;1;30;90;41m8[0;1;31;91;43m8888888888[0;1;30;90;43mS[0;1;30;90;41m8[0;31;40m [0;34;40m   [0;31;40m:[0;1;30;90;43m%[0;1;33;93;43m;ttt%[0;33;5;43;103m%tttt;;[0;1;30;90;43mX[0;34;40m    [0m    [0;31;5;41;101m8                              8[0m    \n" "[0;34;40m    [0;31;40m%[0;1;31;91;43m888888888[0;1;30;90;43m%[0;31;40mt[0;34;40m    [0;30;41m8[0;1;30;90;43mS[0;1;33;93;43m:;;;tt%%[0;33;5;43;103m%ttt;[0;1;30;90;41m8[0;34;40m    [0m      [0;31;5;41;101m:                          :[0m      \n" " [0;34;40m    [0;31;43m8t[0;1;31;91;43m888888[0;33;41m8[0;31;40m [0;34;40m    [0;31;40mS[0;33;41m888[0;31;43m8888[0;1;30;90;43mS[0;1;33;93;43mtt%%[0;33;5;43;103m%t[0;1;30;90;43m@[0;31;40m [0;34;40m   [0m        [0;1;31;91;41m:[0;31;5;41;101m:                      :[0;1;31;91;41m:[0m       \n" " [0;34;40m    [0;31;40m.[0;31;43m@tt[0;1;31;91;43m888[0;31;43m@[0;34;40m              [0;1;30;90;41m8[0;1;33;93;43m;;ttt[0;1;30;90;43m@[0;31;40m;[0;34;40m    [0m           [0;31;5;41;101mt                  t[0m          \n" "  [0;34;40m    [0;31;40m.[0;31;43m8ttt[0;1;31;91;43m8[0;31;43m@[0;31;40mSSSSS[0;34;40m    [0;31;40mSXXXX[0;1;30;90;43m%[0;1;33;93;43m:;;;[0;1;30;90;43mX[0;31;40m;[0;34;40m    [0m              [0;31;5;41;101m8              8[0m            \n" "   [0;34;40m     [0;31;40mX[0;31;43m8ttt[0;1;31;91;43m8888[0;1;30;90;43m%[0;34;40m    [0;1;30;90;43m%[0;1;31;91;43m88[0;1;33;93;43m...::[0;1;30;90;43mX[0;30;41m8[0;31;40m [0;34;40m    [0m                 [0;1;31;91;41mX[0;31;5;41;101m.        .[0;1;31;91;41mX[0m              \n" "     [0;34;40m     [0;31;40m%[0;1;30;90;41m8[0;31;43m@tt[0;1;31;91;43m88[0;31;43m;[0;33;41m8888[0;1;30;90;43m%[0;1;31;91;43m8888[0;1;30;90;43m%[0;31;43m8[0;31;40mX[0;32;40m [0;34;40m    [0m                     [0;1;31;91;41m:[0;31;5;41;101m;    ;[0;1;31;91;41m:[0m                \n" "       [0;34;40m      [0;31;40m:@[0;1;30;90;41m8[0;33;41m8[0;31;43m8@XXX@8[0;1;30;90;41m8[0;31;40m8:[0;34;40m      [0m                          [0;31;5;41;101mtt[0m                   \n" "         [0;34;40m                      [0m                                                 \n" "              [0;34;40m             [0m                                                     "


text:
= view.GetValueIn(chainActive.Tip()->nHeight,&interest,tx,chainActive.Tip()->nTime)-tx.GetValueOut()


text:
do { mp_limb_t __clz_x = (x); uint32_t __clz_c; for (__clz_c = 0; (__clz_x & ((mp_limb_t) 0xff << (GMP_LIMB_BITS - 8))) == 0; __clz_c += 8) __clz_x <<= 8; for (; (__clz_x & GMP_LIMB_HIGHBIT) == 0; __clz_c++) __clz_x <<= 1; (count) = __clz_c; } while (0)


text:
do { mp_limb_t __ctz_x = (x); uint32_t __ctz_c = 0; gmp_clz (__ctz_c, __ctz_x & - (int64_t)__ctz_x); (count) = GMP_LIMB_BITS - 1 - (int64_t)__ctz_c; } while (0)


text:
do { mp_limb_t __x0, __x1, __x2, __x3; uint32_t __ul, __vl, __uh, __vh; mp_limb_t __u = (u), __v = (v); __ul = __u & GMP_LLIMB_MASK; __uh = __u >> (GMP_LIMB_BITS / 2); __vl = __v & GMP_LLIMB_MASK; __vh = __v >> (GMP_LIMB_BITS / 2); __x0 = (mp_limb_t) __ul * __vl; __x1 = (mp_limb_t) __ul * __vh; __x2 = (mp_limb_t) __uh * __vl; __x3 = (mp_limb_t) __uh * __vh; __x1 += __x0 >> (GMP_LIMB_BITS / 2); __x1 += __x2; if (__x1 < __x2) __x3 += GMP_HLIMB_BIT; (w1) = __x3 + (__x1 >> (GMP_LIMB_BITS / 2)); (w0) = (__x1 << (GMP_LIMB_BITS / 2)) + (__x0 & GMP_LLIMB_MASK); } while (0)


text:
do { mp_limb_t _qh, _ql, _r, _mask; gmp_umul_ppmm (_qh, _ql, (nh), (di)); gmp_add_ssaaaa (_qh, _ql, _qh, _ql, (nh) + 1, (nl)); _r = (nl) - _qh * (d); _mask = -(_r > _ql); _qh += _mask; _r += _mask & (d); if (_r >= (d)) { _r -= (d); _qh++; } (r) = _r; (q) = _qh; } while (0)


text:
do { mp_limb_t _q0, _t1, _t0, _mask; gmp_umul_ppmm ((q), _q0, (n2), (dinv)); gmp_add_ssaaaa ((q), _q0, (q), _q0, (n2), (n1)); (r1) = (n1) - (d1) * (q); gmp_sub_ddmmss ((r1), (r0), (r1), (n0), (d1), (d0)); gmp_umul_ppmm (_t1, _t0, (d0), (q)); gmp_sub_ddmmss ((r1), (r0), (r1), (r0), _t1, _t0); (q)++; _mask = -((r1) >= _q0); (q) += _mask; gmp_add_ssaaaa ((r1), (r0), (r1), (r0), _mask & (d1), _mask & (d0)); if ((r1) >= (d1)) { if ((r1) > (d1) || (r0) >= (d0)) { (q)++; gmp_sub_ddmmss ((r1), (r0), (r1), (r0), (d1), (d0)); } } } while (0)


text:
do { mp_bitcnt_t __mp_bitcnt_t_swap__tmp = (x); (x) = (y); (y) = __mp_bitcnt_t_swap__tmp; } while (0)


text:
(vEvictionCandidates.end()-std::min(4,static_cast<int>(vEvictionCandidates.size())),vEvictionCandidates.end())


text:
(vEvictionCandidates.end()-std::min(8,static_cast<int>(vEvictionCandidates.size())),vEvictionCandidates.end())


text:
(vEvictionCandidates.end()-static_cast<int>(vEvictionCandidates.size()/2),vEvictionCandidates.end())


text:
= {{"/rest/tx/",rest_tx},{"/rest/block/notxdetails/",rest_block_notxdetails},{"/rest/block/",rest_block_extended},{"/rest/chaininfo",rest_chaininfo},{"/rest/mempool/info",rest_mempool_info},{"/rest/mempool/contents",rest_mempool_contents},{"/rest/headers/",rest_headers},{"/rest/getutxos",rest_getutxos},}


text:
= {{"stop",0},{"setmocktime",0},{"getaddednodeinfo",0},{"setgenerate",0},{"setgenerate",1},{"generate",0},{"getnetworkhashps",0},{"getnetworkhashps",1},{"sendtoaddress",1},{"sendtoaddress",4},{"settxfee",0},{"getreceivedbyaddress",1},{"getreceivedbyaccount",1},{"listreceivedbyaddress",0},{"listreceivedbyaddress",1},{"listreceivedbyaddress",2},{"listreceivedbyaccount",0},{"listreceivedbyaccount",1},{"listreceivedbyaccount",2},{"getbalance",1},{"getbalance",2},{"getblockhash",0},{"move",2},{"move",3},{"sendfrom",2},{"sendfrom",3},{"listtransactions",1},{"listtransactions",2},{"listtransactions",3},{"listaccounts",0},{"listaccounts",1},{"walletpassphrase",1},{"getblocktemplate",0},{"listsinceblock",1},{"listsinceblock",2},{"sendmany",1},{"sendmany",2},{"sendmany",4},{"addmultisigaddress",0},{"addmultisigaddress",1},{"createmultisig",0},{"createmultisig",1},{"listunspent",0},{"listunspent",1},{"listunspent",2},{"getblock",1},{"getblockheader",1},{"gettransaction",1},{"getrawtransaction",1},{"createrawtransaction",0},{"createrawtransaction",1},{"signrawtransaction",1},{"signrawtransaction",2},{"sendrawtransaction",1},{"fundrawtransaction",1},{"gettxout",1},{"gettxout",2},{"gettxoutproof",0},{"lockunspent",0},{"lockunspent",1},{"importprivkey",2},{"importaddress",2},{"verifychain",0},{"verifychain",1},{"keypoolrefill",0},{"getrawmempool",0},{"estimatefee",0},{"estimatepriority",0},{"prioritisetransaction",1},{"prioritisetransaction",2},{"setban",2},{"setban",3},{"zcrawjoinsplit",1},{"zcrawjoinsplit",2},{"zcrawjoinsplit",3},{"zcrawjoinsplit",4},{"zcbenchmark",1},{"zcbenchmark",2},{"getblocksubsidy",0},{"z_listreceivedbyaddress",1},{"z_getbalance",1},{"z_gettotalbalance",0},{"z_sendmany",1},{"z_sendmany",2},{"z_sendmany",3},{"z_getoperationstatus",0},{"z_getoperationresult",0},{"z_importkey",1},{"paxprice",4},{"paxprices",3},{"paxpending",0},{"notaries",1},{"minerids",1},{"kvsearch",1},{"kvupdate",4},{"z_importkey",2},}


text:
= {{"control","getinfo",&getinfo,true},{"control","help",&help,true},{"control","stop",&stop,true},{"network","getnetworkinfo",&getnetworkinfo,true},{"network","addnode",&addnode,true},{"network","disconnectnode",&disconnectnode,true},{"network","getaddednodeinfo",&getaddednodeinfo,true},{"network","getconnectioncount",&getconnectioncount,true},{"network","getnettotals",&getnettotals,true},{"network","getpeerinfo",&getpeerinfo,true},{"network","ping",&ping,true},{"network","setban",&setban,true},{"network","listbanned",&listbanned,true},{"network","clearbanned",&clearbanned,true},{"blockchain","getblockchaininfo",&getblockchaininfo,true},{"blockchain","getbestblockhash",&getbestblockhash,true},{"blockchain","getblockcount",&getblockcount,true},{"blockchain","getblock",&getblock,true},{"blockchain","getblockhash",&getblockhash,true},{"blockchain","getblockheader",&getblockheader,true},{"blockchain","getchaintips",&getchaintips,true},{"blockchain","getdifficulty",&getdifficulty,true},{"blockchain","getmempoolinfo",&getmempoolinfo,true},{"blockchain","getrawmempool",&getrawmempool,true},{"blockchain","gettxout",&gettxout,true},{"blockchain","gettxoutproof",&gettxoutproof,true},{"blockchain","verifytxoutproof",&verifytxoutproof,true},{"blockchain","gettxoutsetinfo",&gettxoutsetinfo,true},{"blockchain","verifychain",&verifychain,true},{"blockchain","paxprice",&paxprice,true},{"blockchain","paxpending",&paxpending,true},{"blockchain","paxprices",&paxprices,true},{"blockchain","notaries",&notaries,true},{"blockchain","minerids",&minerids,true},{"blockchain","kvsearch",&kvsearch,true},{"blockchain","kvupdate",&kvupdate,true},{"mining","getblocktemplate",&getblocktemplate,true},{"mining","getmininginfo",&getmininginfo,true},{"mining","getlocalsolps",&getlocalsolps,true},{"mining","getnetworksolps",&getnetworksolps,true},{"mining","getnetworkhashps",&getnetworkhashps,true},{"mining","prioritisetransaction",&prioritisetransaction,true},{"mining","submitblock",&submitblock,true},{"mining","getblocksubsidy",&getblocksubsidy,true},{"generating","getgenerate",&getgenerate,true},{"generating","setgenerate",&setgenerate,true},{"generating","generate",&generate,true},{"rawtransactions","createrawtransaction",&createrawtransaction,true},{"rawtransactions","decoderawtransaction",&decoderawtransaction,true},{"rawtransactions","decodescript",&decodescript,true},{"rawtransactions","getrawtransaction",&getrawtransaction,true},{"rawtransactions","sendrawtransaction",&sendrawtransaction,false},{"rawtransactions","signrawtransaction",&signrawtransaction,false},{"rawtransactions","fundrawtransaction",&fundrawtransaction,false},{"util","createmultisig",&createmultisig,true},{"util","validateaddress",&validateaddress,true},{"util","verifymessage",&verifymessage,true},{"util","estimatefee",&estimatefee,true},{"util","estimatepriority",&estimatepriority,true},{"util","z_validateaddress",&z_validateaddress,true},{"util","jumblr_deposit",&jumblr_deposit,true},{"util","jumblr_secret",&jumblr_secret,true},{"util","jumblr_pause",&jumblr_pause,true},{"util","jumblr_resume",&jumblr_resume,true},{"hidden","invalidateblock",&invalidateblock,true},{"hidden","reconsiderblock",&reconsiderblock,true},{"hidden","setmocktime",&setmocktime,true},{"hidden","resendwallettransactions",&resendwallettransactions,true},{"wallet","addmultisigaddress",&addmultisigaddress,true},{"wallet","backupwallet",&backupwallet,true},{"wallet","dumpprivkey",&dumpprivkey,true},{"wallet","dumpwallet",&dumpwallet,true},{"wallet","encryptwallet",&encryptwallet,true},{"wallet","getaccountaddress",&getaccountaddress,true},{"wallet","getaccount",&getaccount,true},{"wallet","getaddressesbyaccount",&getaddressesbyaccount,true},{"wallet","getbalance",&getbalance,false},{"wallet","getnewaddress",&getnewaddress,true},{"wallet","getrawchangeaddress",&getrawchangeaddress,true},{"wallet","getreceivedbyaccount",&getreceivedbyaccount,false},{"wallet","getreceivedbyaddress",&getreceivedbyaddress,false},{"wallet","gettransaction",&gettransaction,false},{"wallet","getunconfirmedbalance",&getunconfirmedbalance,false},{"wallet","getwalletinfo",&getwalletinfo,false},{"wallet","importprivkey",&importprivkey,true},{"wallet","importwallet",&importwallet,true},{"wallet","importaddress",&importaddress,true},{"wallet","keypoolrefill",&keypoolrefill,true},{"wallet","listaccounts",&listaccounts,false},{"wallet","listaddressgroupings",&listaddressgroupings,false},{"wallet","listlockunspent",&listlockunspent,false},{"wallet","listreceivedbyaccount",&listreceivedbyaccount,false},{"wallet","listreceivedbyaddress",&listreceivedbyaddress,false},}


text:
size_t GetSerializeSize(int nType, int nVersion) const { CSizeComputer s(nType, nVersion); NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion); return s.size(); } template<typename Stream> void Serialize(Stream& s, int nType, int nVersion) const { NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize(), nType, nVersion); } template<typename Stream> void Unserialize(Stream& s, int nType, int nVersion) { SerializationOp(s, CSerActionUnserialize(), nType, nVersion); }


text:
CCriticalBlock criticalblock1(cs1, #cs1, __FILE__, __LINE__), criticalblock2(cs2, #cs2, __FILE__, __LINE__)


text:
inline void formatTruncated(std::ostream& out, type* value, int ntrunc) { std::streamsize len = 0; while(len < ntrunc && value[len] != 0) ++len; out.write(value, len); }


text:
inline void formatValue(std::ostream& out, const char* , const char* fmtEnd, int , charType value) { switch(*(fmtEnd-1)) { case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': out << static_cast<int>(value); break; default: out << value; break; } }


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15


text:
class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15


text:
const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16


text:
template<TINYFORMAT_ARGTYPES(n)> FormatListN(TINYFORMAT_VARARGS(n)) : FormatList(&m_formatterStore[0], n) { assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); } template<TINYFORMAT_ARGTYPES(n)> void init(int i, TINYFORMAT_VARARGS(n)) { m_formatterStore[i] = FormatArg(v1); init(i+1 TINYFORMAT_PASSARGS_TAIL(n)); }


text:
template<TINYFORMAT_ARGTYPES(n)> detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) { return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n)); }


text:
template<TINYFORMAT_ARGTYPES(n)> void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n)) { vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n))); } template<TINYFORMAT_ARGTYPES(n)> std::string format(const char* fmt, TINYFORMAT_VARARGS(n)) { std::ostringstream oss; format(oss, fmt, TINYFORMAT_PASSARGS(n)); return oss.str(); } template<TINYFORMAT_ARGTYPES(n)> void printf(const char* fmt, TINYFORMAT_VARARGS(n)) { format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); } template<TINYFORMAT_ARGTYPES(n)> void printfln(const char* fmt, TINYFORMAT_VARARGS(n)) { format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); std::cout << '\n'; }


text:
("AUTHCHALLENGE SAFECOOKIE "+HexStr(clientNonce),boost::bind(&TorController::authchallenge_cb,this,_1,_2))


text:
= (BTN_OK|BTN_YES|BTN_NO|BTN_ABORT|BTN_RETRY|BTN_IGNORE|BTN_CLOSE|BTN_CANCEL|BTN_DISCARD|BTN_HELP|BTN_APPLY|BTN_RESET)


text:
do { out=NULL; if (head) { uint32_t _hf_bkt,_hf_hashv; HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) { HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], keyptr,keylen,out); } } } while (0)


text:
do { (tbl)->bloom_nbits = HASH_BLOOM; (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; } while (0)


text:
do { (head)->hh.tbl = (UT_hash_table*)uthash_malloc( sizeof(UT_hash_table)); if (!((head)->hh.tbl)) { uthash_fatal( "out of memory"); } memset((head)->hh.tbl, 0, sizeof(UT_hash_table)); (head)->hh.tbl->tail = &((head)->hh); (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); } memset((head)->hh.tbl->buckets, 0, HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); HASH_BLOOM_MAKE((head)->hh.tbl); (head)->hh.tbl->signature = HASH_SIGNATURE; } while(0)


text:
do { replaced=NULL; HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced); if (replaced!=NULL) { HASH_DELETE(hh,head,replaced); }; HASH_ADD(hh,head,fieldname,keylen_in,add); } while(0)


text:
do { uint32_t _ha_bkt; (add)->hh.next = NULL; (add)->hh.key = (char*)(keyptr); (add)->hh.keylen = (uint32_t)(keylen_in); if (!(head)) { head = (add); (head)->hh.prev = NULL; HASH_MAKE_TABLE(hh,head); } else { (head)->hh.tbl->tail->next = (add); (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); (head)->hh.tbl->tail = &((add)->hh); } (head)->hh.tbl->num_items++; (add)->hh.tbl = (head)->hh.tbl; HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets, (add)->hh.hashv, _ha_bkt); HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh); HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv); HASH_EMIT_KEY(hh,head,keyptr,keylen_in); HASH_FSCK(hh,head); } while(0)


text:
do { struct UT_hash_handle *_hd_hh_del; if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) ) { uthash_free((head)->hh.tbl->buckets, (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); HASH_BLOOM_FREE((head)->hh.tbl); uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); head = NULL; } else { uint32_t _hd_bkt; _hd_hh_del = &((delptr)->hh); if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { (head)->hh.tbl->tail = (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + (head)->hh.tbl->hho); } if ((delptr)->hh.prev) { ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + (head)->hh.tbl->hho))->next = (delptr)->hh.next; } else { DECLTYPE_ASSIGN(head,(delptr)->hh.next); } if (_hd_hh_del->next) { ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + (head)->hh.tbl->hho))->prev = _hd_hh_del->prev; } HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); (head)->hh.tbl->num_items--; } HASH_FSCK(hh,head); } while (0)


text:
do { struct UT_hash_handle *_thh; if (head) { uint32_t _bkt_i; uint32_t _count; char *_prev; _count = 0; for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) { uint32_t _bkt_count = 0; _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; _prev = NULL; while (_thh) { if (_prev != (char*)(_thh->hh_prev)) { HASH_OOPS("invalid hh_prev %p, actual %p\n", _thh->hh_prev, _prev ); } _bkt_count++; _prev = (char*)(_thh); _thh = _thh->hh_next; } _count += _bkt_count; if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { HASH_OOPS("invalid bucket count %u, actual %u\n", (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); } } if (_count != (head)->hh.tbl->num_items) { HASH_OOPS("invalid hh item count %u, actual %u\n", (head)->hh.tbl->num_items, _count ); } _count = 0; _prev = NULL; _thh = &(head)->hh; while (_thh) { _count++; if (_prev !=(char*)(_thh->prev)) { HASH_OOPS("invalid prev %p, actual %p\n", _thh->prev, _prev ); } _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); _thh = ( _thh->next ? (UT_hash_handle*)((char*)(_thh->next) + (head)->hh.tbl->hho) : NULL ); } if (_count != (head)->hh.tbl->num_items) { HASH_OOPS("invalid app item count %u, actual %u\n", (head)->hh.tbl->num_items, _count ); } } } while (0)


text:
do { uint32_t _klen = fieldlen; write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); write(HASH_EMIT_KEYS, keyptr, fieldlen); } while (0)


text:
do { uint32_t _hb_keylen=keylen; char *_hb_key=(char*)(key); (hashv) = 0; while (_hb_keylen--) { (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++; } bkt = (hashv) & (num_bkts-1); } while (0)


text:
do { uint32_t _sx_i; char *_hs_key=(char*)(key); hashv = 0; for(_sx_i=0; _sx_i < keylen; _sx_i++) hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; bkt = hashv & (num_bkts-1); } while (0)


text:
do { uint32_t _fn_i; char *_hf_key=(char*)(key); hashv = 2166136261UL; for(_fn_i=0; _fn_i < keylen; _fn_i++) { hashv = hashv ^ _hf_key[_fn_i]; hashv = hashv * 16777619; } bkt = hashv & (num_bkts-1); } while(0)


text:
do { uint32_t _ho_i; char *_ho_key=(char*)(key); hashv = 0; for(_ho_i=0; _ho_i < keylen; _ho_i++) { hashv += _ho_key[_ho_i]; hashv += (hashv << 10); hashv ^= (hashv >> 6); } hashv += (hashv << 3); hashv ^= (hashv >> 11); hashv += (hashv << 15); bkt = hashv & (num_bkts-1); } while(0)


text:
do { a -= b; a -= c; a ^= ( c >> 13 ); b -= c; b -= a; b ^= ( a << 8 ); c -= a; c -= b; c ^= ( b >> 13 ); a -= b; a -= c; a ^= ( c >> 12 ); b -= c; b -= a; b ^= ( a << 16 ); c -= a; c -= b; c ^= ( b >> 5 ); a -= b; a -= c; a ^= ( c >> 3 ); b -= c; b -= a; b ^= ( a << 10 ); c -= a; c -= b; c ^= ( b >> 15 ); } while (0)


text:
do { uint32_t _hj_i,_hj_j,_hj_k; unsigned char *_hj_key=(unsigned char*)(key); hashv = 0xfeedbeef; _hj_i = _hj_j = 0x9e3779b9; _hj_k = (uint32_t)(keylen); while (_hj_k >= 12) { _hj_i += (_hj_key[0] + ( (uint32_t)_hj_key[1] << 8 ) + ( (uint32_t)_hj_key[2] << 16 ) + ( (uint32_t)_hj_key[3] << 24 ) ); _hj_j += (_hj_key[4] + ( (uint32_t)_hj_key[5] << 8 ) + ( (uint32_t)_hj_key[6] << 16 ) + ( (uint32_t)_hj_key[7] << 24 ) ); hashv += (_hj_key[8] + ( (uint32_t)_hj_key[9] << 8 ) + ( (uint32_t)_hj_key[10] << 16 ) + ( (uint32_t)_hj_key[11] << 24 ) ); HASH_JEN_MIX(_hj_i, _hj_j, hashv); _hj_key += 12; _hj_k -= 12; } hashv += keylen; switch ( _hj_k ) { case 11: hashv += ( (uint32_t)_hj_key[10] << 24 ); case 10: hashv += ( (uint32_t)_hj_key[9] << 16 ); case 9: hashv += ( (uint32_t)_hj_key[8] << 8 ); case 8: _hj_j += ( (uint32_t)_hj_key[7] << 24 ); case 7: _hj_j += ( (uint32_t)_hj_key[6] << 16 ); case 6: _hj_j += ( (uint32_t)_hj_key[5] << 8 ); case 5: _hj_j += _hj_key[4]; case 4: _hj_i += ( (uint32_t)_hj_key[3] << 24 ); case 3: _hj_i += ( (uint32_t)_hj_key[2] << 16 ); case 2: _hj_i += ( (uint32_t)_hj_key[1] << 8 ); case 1: _hj_i += _hj_key[0]; } HASH_JEN_MIX(_hj_i, _hj_j, hashv); bkt = hashv & (num_bkts-1); } while(0)


text:
do { unsigned char *_sfh_key=(unsigned char*)(key); uint32_t _sfh_tmp, _sfh_len = keylen; int _sfh_rem = _sfh_len & 3; _sfh_len >>= 2; hashv = 0xcafebabe; for (;_sfh_len > 0; _sfh_len--) { hashv += get16bits (_sfh_key); _sfh_tmp = (uint32_t)(get16bits (_sfh_key+2)) << 11 ^ hashv; hashv = (hashv << 16) ^ _sfh_tmp; _sfh_key += 2*sizeof (uint16_t); hashv += hashv >> 11; } switch (_sfh_rem) { case 3: hashv += get16bits (_sfh_key); hashv ^= hashv << 16; hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)] << 18); hashv += hashv >> 11; break; case 2: hashv += get16bits (_sfh_key); hashv ^= hashv << 11; hashv += hashv >> 17; break; case 1: hashv += *_sfh_key; hashv ^= hashv << 10; hashv += hashv >> 1; } hashv ^= hashv << 3; hashv += hashv >> 5; hashv ^= hashv << 4; hashv += hashv >> 17; hashv ^= hashv << 25; hashv += hashv >> 6; bkt = hashv & (num_bkts-1); } while(0)


text:
(MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) : MUR_ONE_THREE(p))))


text:
do { _h ^= _h >> 16; _h *= 0x85ebca6b; _h ^= _h >> 13; _h *= 0xc2b2ae35l; _h ^= _h >> 16; } while(0)


text:
do { const uint8_t *_mur_data = (const uint8_t*)(key); const int _mur_nblocks = (keylen) / 4; uint32_t _mur_h1 = 0xf88D5353; uint32_t _mur_c1 = 0xcc9e2d51; uint32_t _mur_c2 = 0x1b873593; uint32_t _mur_k1 = 0; const uint8_t *_mur_tail; const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); int _mur_i; for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) { _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); _mur_k1 *= _mur_c1; _mur_k1 = MUR_ROTL32(_mur_k1,15); _mur_k1 *= _mur_c2; _mur_h1 ^= _mur_k1; _mur_h1 = MUR_ROTL32(_mur_h1,13); _mur_h1 = _mur_h1*5+0xe6546b64; } _mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); _mur_k1=0; switch((keylen) & 3) { case 3: _mur_k1 ^= _mur_tail[2] << 16; case 2: _mur_k1 ^= _mur_tail[1] << 8; case 1: _mur_k1 ^= _mur_tail[0]; _mur_k1 *= _mur_c1; _mur_k1 = MUR_ROTL32(_mur_k1,15); _mur_k1 *= _mur_c2; _mur_h1 ^= _mur_k1; } _mur_h1 ^= (keylen); MUR_FMIX(_mur_h1); hashv = _mur_h1; bkt = hashv & (num_bkts-1); } while(0)


text:
do { if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); else out=NULL; while (out) { if ((out)->hh.keylen == keylen_in) { if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break; } if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); else out = NULL; } } while(0)


text:
do { head.count++; (addhh)->hh_next = head.hh_head; (addhh)->hh_prev = NULL; if (head.hh_head) { (head).hh_head->hh_prev = (addhh); } (head).hh_head=addhh; if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH) && (addhh)->tbl->noexpand != 1) { HASH_EXPAND_BUCKETS((addhh)->tbl); } } while(0)


text:
(head).count--; if ((head).hh_head == hh_del) { (head).hh_head = hh_del->hh_next; } if (hh_del->hh_prev) { hh_del->hh_prev->hh_next = hh_del->hh_next; } if (hh_del->hh_next) { hh_del->hh_next->hh_prev = hh_del->hh_prev; }


text:
do { uint32_t _he_bkt; uint32_t _he_bkt_i; struct UT_hash_handle *_he_thh, *_he_hh_nxt; UT_hash_bucket *_he_new_buckets, *_he_newbkt; _he_new_buckets = (UT_hash_bucket*)uthash_malloc( 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); if (!_he_new_buckets) { uthash_fatal( "out of memory"); } memset(_he_new_buckets, 0, 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); tbl->ideal_chain_maxlen = (tbl->num_items >> (tbl->log2_num_buckets+1)) + ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0); tbl->nonideal_items = 0; for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++) { _he_thh = tbl->buckets[ _he_bkt_i ].hh_head; while (_he_thh) { _he_hh_nxt = _he_thh->hh_next; HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt); _he_newbkt = &(_he_new_buckets[ _he_bkt ]); if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) { tbl->nonideal_items++; _he_newbkt->expand_mult = _he_newbkt->count / tbl->ideal_chain_maxlen; } _he_thh->hh_prev = NULL; _he_thh->hh_next = _he_newbkt->hh_head; if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev = _he_thh; _he_newbkt->hh_head = _he_thh; _he_thh = _he_hh_nxt; } } uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); tbl->num_buckets *= 2; tbl->log2_num_buckets++; tbl->buckets = _he_new_buckets; tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ? (tbl->ineff_expands+1) : 0; if (tbl->ineff_expands > 1) { tbl->noexpand=1; uthash_noexpand_fyi(tbl); } uthash_expand_fyi(tbl); } while(0)


text:
do { uint32_t _hs_i; uint32_t _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; if (head) { _hs_insize = 1; _hs_looping = 1; _hs_list = &((head)->hh); while (_hs_looping) { _hs_p = _hs_list; _hs_list = NULL; _hs_tail = NULL; _hs_nmerges = 0; while (_hs_p) { _hs_nmerges++; _hs_q = _hs_p; _hs_psize = 0; for ( _hs_i = 0; _hs_i < _hs_insize; _hs_i++ ) { _hs_psize++; _hs_q = (UT_hash_handle*)((_hs_q->next) ? ((void*)((char*)(_hs_q->next) + (head)->hh.tbl->hho)) : NULL); if (! (_hs_q) ) break; } _hs_qsize = _hs_insize; while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) { if (_hs_psize == 0) { _hs_e = _hs_q; _hs_q = (UT_hash_handle*)((_hs_q->next) ? ((void*)((char*)(_hs_q->next) + (head)->hh.tbl->hho)) : NULL); _hs_qsize--; } else if ( (_hs_qsize == 0) || !(_hs_q) ) { _hs_e = _hs_p; if (_hs_p){ _hs_p = (UT_hash_handle*)((_hs_p->next) ? ((void*)((char*)(_hs_p->next) + (head)->hh.tbl->hho)) : NULL); } _hs_psize--; } else if (( cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) ) <= 0) { _hs_e = _hs_p; if (_hs_p){ _hs_p = (UT_hash_handle*)((_hs_p->next) ? ((void*)((char*)(_hs_p->next) + (head)->hh.tbl->hho)) : NULL); } _hs_psize--; } else { _hs_e = _hs_q; _hs_q = (UT_hash_handle*)((_hs_q->next) ? ((void*)((char*)(_hs_q->next) + (head)->hh.tbl->hho)) : NULL); _hs_qsize--; } if ( _hs_tail ) { _hs_tail->next = ((_hs_e) ? ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); } else { _hs_list = _hs_e; } if (_hs_e) { _hs_e->prev = ((_hs_tail) ? ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); } _hs_tail = _hs_e; } _hs_p = _hs_q; } if (_hs_tail){ _hs_tail->next = NULL; } if ( _hs_nmerges <= 1 ) { _hs_looping=0; (head)->hh.tbl->tail = _hs_tail; DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list)); } _hs_insize *= 2; } HASH_FSCK(hh,head); } } while (0)


text:
do { uint32_t _src_bkt, _dst_bkt; void *_last_elt=NULL, *_elt; UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); if (src) { for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; _src_hh; _src_hh = _src_hh->hh_next) { _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); if (cond(_elt)) { _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); _dst_hh->key = _src_hh->key; _dst_hh->keylen = _src_hh->keylen; _dst_hh->hashv = _src_hh->hashv; _dst_hh->prev = _last_elt; _dst_hh->next = NULL; if (_last_elt_hh) { _last_elt_hh->next = _elt; } if (!dst) { DECLTYPE_ASSIGN(dst,_elt); HASH_MAKE_TABLE(hh_dst,dst); } else { _dst_hh->tbl = (dst)->hh_dst.tbl; } HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); (dst)->hh_dst.tbl->num_items++; _last_elt = _elt; _last_elt_hh = _dst_hh; } } } } HASH_FSCK(hh_dst,dst); } while (0)


text:
do { if (head) { uthash_free((head)->hh.tbl->buckets, (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); HASH_BLOOM_FREE((head)->hh.tbl); uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); (head)=NULL; } } while(0)


text:
(size_t)((((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + (sizeof(UT_hash_table)) + (HASH_BLOOM_BYTELEN)))


text:
for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))


text:
for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))


text:
template<TINYFORMAT_ARGTYPES(n)> static inline int LogPrint(const char* category, const char* format, TINYFORMAT_VARARGS(n)) { if(!LogAcceptCategory(category)) return 0; return LogPrintStr(tfm::format(format, TINYFORMAT_PASSARGS(n))); } template<TINYFORMAT_ARGTYPES(n)> static inline bool error(const char* format, TINYFORMAT_VARARGS(n)) { LogPrintStr("ERROR: " + tfm::format(format, TINYFORMAT_PASSARGS(n)) + "\n"); return false; }


text:
= {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,}


text:
do { LDECLTYPE(list) _ls_p; LDECLTYPE(list) _ls_q; LDECLTYPE(list) _ls_e; LDECLTYPE(list) _ls_tail; int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; if (list) { _ls_insize = 1; _ls_looping = 1; while (_ls_looping) { _CASTASGN(_ls_p,list); list = NULL; _ls_tail = NULL; _ls_nmerges = 0; while (_ls_p) { _ls_nmerges++; _ls_q = _ls_p; _ls_psize = 0; for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { _ls_psize++; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); if (!_ls_q) break; } _ls_qsize = _ls_insize; while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { if (_ls_psize == 0) { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; } else if (_ls_qsize == 0 || !_ls_q) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; } else if (cmp(_ls_p,_ls_q) <= 0) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; } else { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; } if (_ls_tail) { _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); } else { _CASTASGN(list,_ls_e); } _ls_tail = _ls_e; } _ls_p = _ls_q; } if (_ls_tail) { _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); } if (_ls_nmerges <= 1) { _ls_looping=0; } _ls_insize *= 2; } } } while (0)


text:
do { LDECLTYPE(list) _ls_p; LDECLTYPE(list) _ls_q; LDECLTYPE(list) _ls_e; LDECLTYPE(list) _ls_tail; int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; if (list) { _ls_insize = 1; _ls_looping = 1; while (_ls_looping) { _CASTASGN(_ls_p,list); list = NULL; _ls_tail = NULL; _ls_nmerges = 0; while (_ls_p) { _ls_nmerges++; _ls_q = _ls_p; _ls_psize = 0; for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { _ls_psize++; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); if (!_ls_q) break; } _ls_qsize = _ls_insize; while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { if (_ls_psize == 0) { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; } else if (_ls_qsize == 0 || !_ls_q) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; } else if (cmp(_ls_p,_ls_q) <= 0) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; } else { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; } if (_ls_tail) { _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); } else { _CASTASGN(list,_ls_e); } _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); _ls_tail = _ls_e; } _ls_p = _ls_q; } _CASTASGN(list->prev, _ls_tail); _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); if (_ls_nmerges <= 1) { _ls_looping=0; } _ls_insize *= 2; } } } while (0)


text:
do { LDECLTYPE(list) _ls_p; LDECLTYPE(list) _ls_q; LDECLTYPE(list) _ls_e; LDECLTYPE(list) _ls_tail; LDECLTYPE(list) _ls_oldhead; LDECLTYPE(list) _tmp; int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; if (list) { _ls_insize = 1; _ls_looping = 1; while (_ls_looping) { _CASTASGN(_ls_p,list); _CASTASGN(_ls_oldhead,list); list = NULL; _ls_tail = NULL; _ls_nmerges = 0; while (_ls_p) { _ls_nmerges++; _ls_q = _ls_p; _ls_psize = 0; for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { _ls_psize++; _SV(_ls_q,list); if (_NEXT(_ls_q,list,next) == _ls_oldhead) { _ls_q = NULL; } else { _ls_q = _NEXT(_ls_q,list,next); } _RS(list); if (!_ls_q) break; } _ls_qsize = _ls_insize; while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { if (_ls_psize == 0) { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; if (_ls_q == _ls_oldhead) { _ls_q = NULL; } } else if (_ls_qsize == 0 || !_ls_q) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; if (_ls_p == _ls_oldhead) { _ls_p = NULL; } } else if (cmp(_ls_p,_ls_q) <= 0) { _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; if (_ls_p == _ls_oldhead) { _ls_p = NULL; } } else { _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; if (_ls_q == _ls_oldhead) { _ls_q = NULL; } } if (_ls_tail) { _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); } else { _CASTASGN(list,_ls_e); } _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); _ls_tail = _ls_e; } _ls_p = _ls_q; } _CASTASGN(list->prev,_ls_tail); _CASTASGN(_tmp,list); _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp,next); _RS(list); if (_ls_nmerges <= 1) { _ls_looping=0; } _ls_insize *= 2; } } } while (0)


text:
do { LDECLTYPE(head1) _tmp; if (head1) { _tmp = head1; while (_tmp->next) { _tmp = _tmp->next; } _tmp->next=(head2); } else { (head1)=(head2); } } while (0)


text:
do { LDECLTYPE(head) _tmp; (add)->next=NULL; if (head) { _tmp = head; while (_tmp->next) { _tmp = _tmp->next; } _tmp->next=(add); } else { (head)=(add); } } while (0)


text:
do { LDECLTYPE(head) _tmp; if ((head) == (del)) { (head)=(head)->next; } else { _tmp = head; while (_tmp->next && (_tmp->next != (del))) { _tmp = _tmp->next; } if (_tmp->next) { _tmp->next = ((del)->next); } } } while (0)


text:
do { if (head) { (add)->next = head; while ((add)->next->next) { (add)->next = (add)->next->next; } (add)->next->next=(add); } else { (head)=(add); } (add)->next=NULL; } while (0)


text:
do { if ((head) == (del)) { (head)=(head)->next; } else { char *_tmp = (char*)(head); while ((head)->next && ((head)->next != (del))) { head = (head)->next; } if ((head)->next) { (head)->next = ((del)->next); } { char **_head_alias = (char**)&(head); *_head_alias = _tmp; } } } while (0)


text:
do { LDECLTYPE(head) _tmp; assert(head != NULL); assert(el != NULL); assert(add != NULL); (add)->next = (el)->next; if ((head) == (el)) { (head) = (add); } else { _tmp = head; while (_tmp->next && (_tmp->next != (el))) { _tmp = _tmp->next; } if (_tmp->next) { _tmp->next = (add); } } } while (0)


text:
do { LDECLTYPE(head) _tmp; assert(head != NULL); assert(el != NULL); assert(add != NULL); (add)->next = (el); if ((head) == (el)) { (head) = (add); } else { _tmp = head; while (_tmp->next && (_tmp->next != (el))) { _tmp = _tmp->next; } if (_tmp->next) { _tmp->next = (add); } } } while (0)


text:
do { (add)->next = head; if (head) { (add)->prev = (head)->prev; (head)->prev = (add); } else { (add)->prev = (add); } (head) = (add); } while (0)


text:
do { if (head) { (add)->prev = (head)->prev; (head)->prev->next = (add); (head)->prev = (add); (add)->next = NULL; } else { (head)=(add); (head)->prev = (head); (head)->next = NULL; } } while (0)


text:
do { LDECLTYPE(head1) _tmp; if (head2) { if (head1) { _tmp = (head2)->prev; (head2)->prev = (head1)->prev; (head1)->prev->next = (head2); (head1)->prev = _tmp; } else { (head1)=(head2); } } } while (0)


text:
do { assert((del)->prev != NULL); if ((del)->prev == (del)) { (head)=NULL; } else if ((del)==(head)) { (del)->next->prev = (del)->prev; (head) = (del)->next; } else { (del)->prev->next = (del)->next; if ((del)->next) { (del)->next->prev = (del)->prev; } else { (head)->prev = (del)->prev; } } } while (0)


text:
do { assert(head != NULL); assert(el != NULL); assert(add != NULL); if ((head) == (el)) { (head) = (add); (add)->next = (el)->next; if ((el)->next == NULL) { (add)->prev = (add); } else { (add)->prev = (el)->prev; (add)->next->prev = (add); } } else { (add)->next = (el)->next; (add)->prev = (el)->prev; (add)->prev->next = (add); if ((el)->next == NULL) { (head)->prev = (add); } else { (add)->next->prev = (add); } } } while (0)


text:
do { assert(head != NULL); assert(el != NULL); assert(add != NULL); (add)->next = (el); (add)->prev = (el)->prev; (el)->prev = (add); if ((head) == (el)) { (head) = (add); } else { (add)->prev->next = (add); } } while (0)


text:
do { if (head) { (add)->prev = (head)->prev; (add)->next = (head); (head)->prev = (add); (add)->prev->next = (add); } else { (add)->prev = (add); (add)->next = (add); } (head)=(add); } while (0)


text:
do { if ( ((head)==(del)) && ((head)->next == (head))) { (head) = 0L; } else { (del)->next->prev = (del)->prev; (del)->prev->next = (del)->next; if ((del) == (head)) (head)=(del)->next; } } while (0)


text:
for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL); (el) && ((tmp2)=(el)->next, 1); ((el) = (((el)==(tmp1)) ? 0L : (tmp2))))


text:
do { assert(head != NULL); assert(el != NULL); assert(add != NULL); if ((el)->next == (el)) { (add)->next = (add); (add)->prev = (add); (head) = (add); } else { (add)->next = (el)->next; (add)->prev = (el)->prev; (add)->next->prev = (add); (add)->prev->next = (add); if ((head) == (el)) { (head) = (add); } } } while (0)


text:
do { assert(head != NULL); assert(el != NULL); assert(add != NULL); (add)->next = (el); (add)->prev = (el)->prev; (el)->prev = (add); (add)->prev->next = (add); if ((head) == (el)) { (head) = (add); } } while (0)


text:
if (n == 96 && k == 3) { Eh96_3.InitialiseState(base_state); } else if (n == 200 && k == 9) { Eh200_9.InitialiseState(base_state); } else if (n == 96 && k == 5) { Eh96_5.InitialiseState(base_state); } else if (n == 48 && k == 5) { Eh48_5.InitialiseState(base_state); } else { throw std::invalid_argument("Unsupported Equihash parameters"); }


text:
if (n == 96 && k == 3) { ret = Eh96_3.IsValidSolution(base_state, soln); } else if (n == 200 && k == 9) { ret = Eh200_9.IsValidSolution(base_state, soln); } else if (n == 96 && k == 5) { ret = Eh96_5.IsValidSolution(base_state, soln); } else if (n == 48 && k == 5) { ret = Eh48_5.IsValidSolution(base_state, soln); } else { throw std::invalid_argument("Unsupported Equihash parameters"); }


text:
if ((err) != NULL) { fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, (err)); abort(); }


text:
= "fillseq," "fillsync," "fillrandom," "overwrite," "readrandom," "readrandom," "readseq," "readreverse," "compact," "readrandom," "readseq," "readreverse," "fill100K," "crc32c," "snappycomp," "snappyuncomp," "acquireload,"


text:
= {0,kHeaderSize+10000,2*(kHeaderSize+10000),2*(kHeaderSize+10000)+(2*log::kBlockSize-1000)+3*kHeaderSize}


text:
= "fillseq," "fillseqsync," "fillseqbatch," "fillrandom," "fillrandsync," "fillrandbatch," "overwrite," "overwritebatch," "readrandom," "readseq," "fillrand100K," "fillseq100K," "readseq," "readrand100K,"


text:
= "fillseq," "fillseqsync," "fillrandsync," "fillrandom," "overwrite," "readrandom," "readseq," "fillrand100K," "fillseq100K," "readseq100K," "readrand100K,"


text:
= {{TABLE_TEST,false,16},{TABLE_TEST,false,1},{TABLE_TEST,false,1024},{TABLE_TEST,true,16},{TABLE_TEST,true,1},{TABLE_TEST,true,1024},{BLOCK_TEST,false,16},{BLOCK_TEST,false,1},{BLOCK_TEST,false,1024},{BLOCK_TEST,true,16},{BLOCK_TEST,true,1},{BLOCK_TEST,true,1024},{MEMTABLE_TEST,false,16},{MEMTABLE_TEST,true,16},{DB_TEST,false,16},{DB_TEST,true,16},}


text:
= {0x00000000,0xf26b8303,0xe13b70f7,0x1350f3f4,0xc79a971f,0x35f1141c,0x26a1e7e8,0xd4ca64eb,0x8ad958cf,0x78b2dbcc,0x6be22838,0x9989ab3b,0x4d43cfd0,0xbf284cd3,0xac78bf27,0x5e133c24,0x105ec76f,0xe235446c,0xf165b798,0x030e349b,0xd7c45070,0x25afd373,0x36ff2087,0xc494a384,0x9a879fa0,0x68ec1ca3,0x7bbcef57,0x89d76c54,0x5d1d08bf,0xaf768bbc,0xbc267848,0x4e4dfb4b,0x20bd8ede,0xd2d60ddd,0xc186fe29,0x33ed7d2a,0xe72719c1,0x154c9ac2,0x061c6936,0xf477ea35,0xaa64d611,0x580f5512,0x4b5fa6e6,0xb93425e5,0x6dfe410e,0x9f95c20d,0x8cc531f9,0x7eaeb2fa,0x30e349b1,0xc288cab2,0xd1d83946,0x23b3ba45,0xf779deae,0x05125dad,0x1642ae59,0xe4292d5a,0xba3a117e,0x4851927d,0x5b016189,0xa96ae28a,0x7da08661,0x8fcb0562,0x9c9bf696,0x6ef07595,0x417b1dbc,0xb3109ebf,0xa0406d4b,0x522bee48,0x86e18aa3,0x748a09a0,0x67dafa54,0x95b17957,0xcba24573,0x39c9c670,0x2a993584,0xd8f2b687,0x0c38d26c,0xfe53516f,0xed03a29b,0x1f682198,0x5125dad3,0xa34e59d0,0xb01eaa24,0x42752927,0x96bf4dcc,0x64d4cecf,0x77843d3b,0x85efbe38,0xdbfc821c,0x2997011f,0x3ac7f2eb,0xc8ac71e8,0x1c661503,0xee0d9600,0xfd5d65f4,0x0f36e6f7,0x61c69362,0x93ad1061,0x80fde395,0x72966096,0xa65c047d,0x5437877e,0x4767748a,0xb50cf789,0xeb1fcbad,0x197448ae,0x0a24bb5a,0xf84f3859,0x2c855cb2,0xdeeedfb1,0xcdbe2c45,0x3fd5af46,0x7198540d,0x83f3d70e,0x90a324fa,0x62c8a7f9,0xb602c312,0x44694011,0x5739b3e5,0xa55230e6,0xfb410cc2,0x092a8fc1,0x1a7a7c35,0xe811ff36,0x3cdb9bdd,0xceb018de,0xdde0eb2a,0x2f8b6829,0x82f63b78,0x709db87b,0x63cd4b8f,0x91a6c88c,0x456cac67,0xb7072f64,0xa457dc90,0x563c5f93,0x082f63b7,0xfa44e0b4,0xe9141340,0x1b7f9043,0xcfb5f4a8,0x3dde77ab,0x2e8e845f,0xdce5075c,0x92a8fc17,0x60c37f14,0x73938ce0,0x81f80fe3,0x55326b08,0xa759e80b,0xb4091bff,0x466298fc,0x1871a4d8,0xea1a27db,0xf94ad42f,0x0b21572c,0xdfeb33c7,0x2d80b0c4,0x3ed04330,0xccbbc033,0xa24bb5a6,0x502036a5,0x4370c551,0xb11b4652,0x65d122b9,0x97baa1ba,0x84ea524e,0x7681d14d,0x2892ed69,0xdaf96e6a,0xc9a99d9e,0x3bc21e9d,0xef087a76,0x1d63f975,0x0e330a81,0xfc588982,0xb21572c9,0x407ef1ca,0x532e023e,0xa145813d,0x758fe5d6,0x87e466d5,0x94b49521,0x66df1622,0x38cc2a06,0xcaa7a905,0xd9f75af1,0x2b9cd9f2,0xff56bd19,0x0d3d3e1a,0x1e6dcdee,0xec064eed,0xc38d26c4,0x31e6a5c7,0x22b65633,0xd0ddd530,0x0417b1db,0xf67c32d8,0xe52cc12c,0x1747422f,0x49547e0b,0xbb3ffd08,0xa86f0efc,0x5a048dff,0x8ecee914,0x7ca56a17,0x6ff599e3,0x9d9e1ae0,0xd3d3e1ab,0x21b862a8,0x32e8915c,0xc083125f,0x144976b4,0xe622f5b7,0xf5720643,0x07198540,0x590ab964,0xab613a67,0xb831c993,0x4a5a4a90,0x9e902e7b,0x6cfbad78,0x7fab5e8c,0x8dc0dd8f,0xe330a81a,0x115b2b19,0x020bd8ed,0xf0605bee,0x24aa3f05,0xd6c1bc06,0xc5914ff2,0x37faccf1,0x69e9f0d5,0x9b8273d6,0x88d28022,0x7ab90321,0xae7367ca,0x5c18e4c9,0x4f48173d,0xbd23943e,0xf36e6f75,0x0105ec76,0x12551f82,0xe03e9c81,0x34f4f86a,0xc69f7b69,0xd5cf889d,0x27a40b9e,0x79b737ba,0x8bdcb4b9,0x988c474d,0x6ae7c44e,0xbe2da0a5,0x4c4623a6,0x5f16d052,0xad7d5351}


text:
= {0x00000000,0x13a29877,0x274530ee,0x34e7a899,0x4e8a61dc,0x5d28f9ab,0x69cf5132,0x7a6dc945,0x9d14c3b8,0x8eb65bcf,0xba51f356,0xa9f36b21,0xd39ea264,0xc03c3a13,0xf4db928a,0xe7790afd,0x3fc5f181,0x2c6769f6,0x1880c16f,0x0b225918,0x714f905d,0x62ed082a,0x560aa0b3,0x45a838c4,0xa2d13239,0xb173aa4e,0x859402d7,0x96369aa0,0xec5b53e5,0xfff9cb92,0xcb1e630b,0xd8bcfb7c,0x7f8be302,0x6c297b75,0x58ced3ec,0x4b6c4b9b,0x310182de,0x22a31aa9,0x1644b230,0x05e62a47,0xe29f20ba,0xf13db8cd,0xc5da1054,0xd6788823,0xac154166,0xbfb7d911,0x8b507188,0x98f2e9ff,0x404e1283,0x53ec8af4,0x670b226d,0x74a9ba1a,0x0ec4735f,0x1d66eb28,0x298143b1,0x3a23dbc6,0xdd5ad13b,0xcef8494c,0xfa1fe1d5,0xe9bd79a2,0x93d0b0e7,0x80722890,0xb4958009,0xa737187e,0xff17c604,0xecb55e73,0xd852f6ea,0xcbf06e9d,0xb19da7d8,0xa23f3faf,0x96d89736,0x857a0f41,0x620305bc,0x71a19dcb,0x45463552,0x56e4ad25,0x2c896460,0x3f2bfc17,0x0bcc548e,0x186eccf9,0xc0d23785,0xd370aff2,0xe797076b,0xf4359f1c,0x8e585659,0x9dface2e,0xa91d66b7,0xbabffec0,0x5dc6f43d,0x4e646c4a,0x7a83c4d3,0x69215ca4,0x134c95e1,0x00ee0d96,0x3409a50f,0x27ab3d78,0x809c2506,0x933ebd71,0xa7d915e8,0xb47b8d9f,0xce1644da,0xddb4dcad,0xe9537434,0xfaf1ec43,0x1d88e6be,0x0e2a7ec9,0x3acdd650,0x296f4e27,0x53028762,0x40a01f15,0x7447b78c,0x67e52ffb,0xbf59d487,0xacfb4cf0,0x981ce469,0x8bbe7c1e,0xf1d3b55b,0xe2712d2c,0xd69685b5,0xc5341dc2,0x224d173f,0x31ef8f48,0x050827d1,0x16aabfa6,0x6cc776e3,0x7f65ee94,0x4b82460d,0x5820de7a,0xfbc3faf9,0xe861628e,0xdc86ca17,0xcf245260,0xb5499b25,0xa6eb0352,0x920cabcb,0x81ae33bc,0x66d73941,0x7575a136,0x419209af,0x523091d8,0x285d589d,0x3bffc0ea,0x0f186873,0x1cbaf004,0xc4060b78,0xd7a4930f,0xe3433b96,0xf0e1a3e1,0x8a8c6aa4,0x992ef2d3,0xadc95a4a,0xbe6bc23d,0x5912c8c0,0x4ab050b7,0x7e57f82e,0x6df56059,0x1798a91c,0x043a316b,0x30dd99f2,0x237f0185,0x844819fb,0x97ea818c,0xa30d2915,0xb0afb162,0xcac27827,0xd960e050,0xed8748c9,0xfe25d0be,0x195cda43,0x0afe4234,0x3e19eaad,0x2dbb72da,0x57d6bb9f,0x447423e8,0x70938b71,0x63311306,0xbb8de87a,0xa82f700d,0x9cc8d894,0x8f6a40e3,0xf50789a6,0xe6a511d1,0xd242b948,0xc1e0213f,0x26992bc2,0x353bb3b5,0x01dc1b2c,0x127e835b,0x68134a1e,0x7bb1d269,0x4f567af0,0x5cf4e287,0x04d43cfd,0x1776a48a,0x23910c13,0x30339464,0x4a5e5d21,0x59fcc556,0x6d1b6dcf,0x7eb9f5b8,0x99c0ff45,0x8a626732,0xbe85cfab,0xad2757dc,0xd74a9e99,0xc4e806ee,0xf00fae77,0xe3ad3600,0x3b11cd7c,0x28b3550b,0x1c54fd92,0x0ff665e5,0x759baca0,0x663934d7,0x52de9c4e,0x417c0439,0xa6050ec4,0xb5a796b3,0x81403e2a,0x92e2a65d,0xe88f6f18,0xfb2df76f,0xcfca5ff6,0xdc68c781,0x7b5fdfff,0x68fd4788,0x5c1aef11,0x4fb87766,0x35d5be23,0x26772654,0x12908ecd,0x013216ba,0xe64b1c47,0xf5e98430,0xc10e2ca9,0xd2acb4de,0xa8c17d9b,0xbb63e5ec,0x8f844d75,0x9c26d502,0x449a2e7e,0x5738b609,0x63df1e90,0x707d86e7,0x0a104fa2,0x19b2d7d5,0x2d557f4c,0x3ef7e73b,0xd98eedc6,0xca2c75b1,0xfecbdd28,0xed69455f,0x97048c1a,0x84a6146d,0xb041bcf4,0xa3e32483}


text:
= {0x00000000,0xa541927e,0x4f6f520d,0xea2ec073,0x9edea41a,0x3b9f3664,0xd1b1f617,0x74f06469,0x38513ec5,0x9d10acbb,0x773e6cc8,0xd27ffeb6,0xa68f9adf,0x03ce08a1,0xe9e0c8d2,0x4ca15aac,0x70a27d8a,0xd5e3eff4,0x3fcd2f87,0x9a8cbdf9,0xee7cd990,0x4b3d4bee,0xa1138b9d,0x045219e3,0x48f3434f,0xedb2d131,0x079c1142,0xa2dd833c,0xd62de755,0x736c752b,0x9942b558,0x3c032726,0xe144fb14,0x4405696a,0xae2ba919,0x0b6a3b67,0x7f9a5f0e,0xdadbcd70,0x30f50d03,0x95b49f7d,0xd915c5d1,0x7c5457af,0x967a97dc,0x333b05a2,0x47cb61cb,0xe28af3b5,0x08a433c6,0xade5a1b8,0x91e6869e,0x34a714e0,0xde89d493,0x7bc846ed,0x0f382284,0xaa79b0fa,0x40577089,0xe516e2f7,0xa9b7b85b,0x0cf62a25,0xe6d8ea56,0x43997828,0x37691c41,0x92288e3f,0x78064e4c,0xdd47dc32,0xc76580d9,0x622412a7,0x880ad2d4,0x2d4b40aa,0x59bb24c3,0xfcfab6bd,0x16d476ce,0xb395e4b0,0xff34be1c,0x5a752c62,0xb05bec11,0x151a7e6f,0x61ea1a06,0xc4ab8878,0x2e85480b,0x8bc4da75,0xb7c7fd53,0x12866f2d,0xf8a8af5e,0x5de93d20,0x29195949,0x8c58cb37,0x66760b44,0xc337993a,0x8f96c396,0x2ad751e8,0xc0f9919b,0x65b803e5,0x1148678c,0xb409f5f2,0x5e273581,0xfb66a7ff,0x26217bcd,0x8360e9b3,0x694e29c0,0xcc0fbbbe,0xb8ffdfd7,0x1dbe4da9,0xf7908dda,0x52d11fa4,0x1e704508,0xbb31d776,0x511f1705,0xf45e857b,0x80aee112,0x25ef736c,0xcfc1b31f,0x6a802161,0x56830647,0xf3c29439,0x19ec544a,0xbcadc634,0xc85da25d,0x6d1c3023,0x8732f050,0x2273622e,0x6ed23882,0xcb93aafc,0x21bd6a8f,0x84fcf8f1,0xf00c9c98,0x554d0ee6,0xbf63ce95,0x1a225ceb,0x8b277743,0x2e66e53d,0xc448254e,0x6109b730,0x15f9d359,0xb0b84127,0x5a968154,0xffd7132a,0xb3764986,0x1637dbf8,0xfc191b8b,0x595889f5,0x2da8ed9c,0x88e97fe2,0x62c7bf91,0xc7862def,0xfb850ac9,0x5ec498b7,0xb4ea58c4,0x11abcaba,0x655baed3,0xc01a3cad,0x2a34fcde,0x8f756ea0,0xc3d4340c,0x6695a672,0x8cbb6601,0x29faf47f,0x5d0a9016,0xf84b0268,0x1265c21b,0xb7245065,0x6a638c57,0xcf221e29,0x250cde5a,0x804d4c24,0xf4bd284d,0x51fcba33,0xbbd27a40,0x1e93e83e,0x5232b292,0xf77320ec,0x1d5de09f,0xb81c72e1,0xccec1688,0x69ad84f6,0x83834485,0x26c2d6fb,0x1ac1f1dd,0xbf8063a3,0x55aea3d0,0xf0ef31ae,0x841f55c7,0x215ec7b9,0xcb7007ca,0x6e3195b4,0x2290cf18,0x87d15d66,0x6dff9d15,0xc8be0f6b,0xbc4e6b02,0x190ff97c,0xf321390f,0x5660ab71,0x4c42f79a,0xe90365e4,0x032da597,0xa66c37e9,0xd29c5380,0x77ddc1fe,0x9df3018d,0x38b293f3,0x7413c95f,0xd1525b21,0x3b7c9b52,0x9e3d092c,0xeacd6d45,0x4f8cff3b,0xa5a23f48,0x00e3ad36,0x3ce08a10,0x99a1186e,0x738fd81d,0xd6ce4a63,0xa23e2e0a,0x077fbc74,0xed517c07,0x4810ee79,0x04b1b4d5,0xa1f026ab,0x4bdee6d8,0xee9f74a6,0x9a6f10cf,0x3f2e82b1,0xd50042c2,0x7041d0bc,0xad060c8e,0x08479ef0,0xe2695e83,0x4728ccfd,0x33d8a894,0x96993aea,0x7cb7fa99,0xd9f668e7,0x9557324b,0x3016a035,0xda386046,0x7f79f238,0x0b899651,0xaec8042f,0x44e6c45c,0xe1a75622,0xdda47104,0x78e5e37a,0x92cb2309,0x378ab177,0x437ad51e,0xe63b4760,0x0c158713,0xa954156d,0xe5f54fc1,0x40b4ddbf,0xaa9a1dcc,0x0fdb8fb2,0x7b2bebdb,0xde6a79a5,0x3444b9d6,0x91052ba8}


text:
= {0x00000000,0xdd45aab8,0xbf672381,0x62228939,0x7b2231f3,0xa6679b4b,0xc4451272,0x1900b8ca,0xf64463e6,0x2b01c95e,0x49234067,0x9466eadf,0x8d665215,0x5023f8ad,0x32017194,0xef44db2c,0xe964b13d,0x34211b85,0x560392bc,0x8b463804,0x924680ce,0x4f032a76,0x2d21a34f,0xf06409f7,0x1f20d2db,0xc2657863,0xa047f15a,0x7d025be2,0x6402e328,0xb9474990,0xdb65c0a9,0x06206a11,0xd725148b,0x0a60be33,0x6842370a,0xb5079db2,0xac072578,0x71428fc0,0x136006f9,0xce25ac41,0x2161776d,0xfc24ddd5,0x9e0654ec,0x4343fe54,0x5a43469e,0x8706ec26,0xe524651f,0x3861cfa7,0x3e41a5b6,0xe3040f0e,0x81268637,0x5c632c8f,0x45639445,0x98263efd,0xfa04b7c4,0x27411d7c,0xc805c650,0x15406ce8,0x7762e5d1,0xaa274f69,0xb327f7a3,0x6e625d1b,0x0c40d422,0xd1057e9a,0xaba65fe7,0x76e3f55f,0x14c17c66,0xc984d6de,0xd0846e14,0x0dc1c4ac,0x6fe34d95,0xb2a6e72d,0x5de23c01,0x80a796b9,0xe2851f80,0x3fc0b538,0x26c00df2,0xfb85a74a,0x99a72e73,0x44e284cb,0x42c2eeda,0x9f874462,0xfda5cd5b,0x20e067e3,0x39e0df29,0xe4a57591,0x8687fca8,0x5bc25610,0xb4868d3c,0x69c32784,0x0be1aebd,0xd6a40405,0xcfa4bccf,0x12e11677,0x70c39f4e,0xad8635f6,0x7c834b6c,0xa1c6e1d4,0xc3e468ed,0x1ea1c255,0x07a17a9f,0xdae4d027,0xb8c6591e,0x6583f3a6,0x8ac7288a,0x57828232,0x35a00b0b,0xe8e5a1b3,0xf1e51979,0x2ca0b3c1,0x4e823af8,0x93c79040,0x95e7fa51,0x48a250e9,0x2a80d9d0,0xf7c57368,0xeec5cba2,0x3380611a,0x51a2e823,0x8ce7429b,0x63a399b7,0xbee6330f,0xdcc4ba36,0x0181108e,0x1881a844,0xc5c402fc,0xa7e68bc5,0x7aa3217d,0x52a0c93f,0x8fe56387,0xedc7eabe,0x30824006,0x2982f8cc,0xf4c75274,0x96e5db4d,0x4ba071f5,0xa4e4aad9,0x79a10061,0x1b838958,0xc6c623e0,0xdfc69b2a,0x02833192,0x60a1b8ab,0xbde41213,0xbbc47802,0x6681d2ba,0x04a35b83,0xd9e6f13b,0xc0e649f1,0x1da3e349,0x7f816a70,0xa2c4c0c8,0x4d801be4,0x90c5b15c,0xf2e73865,0x2fa292dd,0x36a22a17,0xebe780af,0x89c50996,0x5480a32e,0x8585ddb4,0x58c0770c,0x3ae2fe35,0xe7a7548d,0xfea7ec47,0x23e246ff,0x41c0cfc6,0x9c85657e,0x73c1be52,0xae8414ea,0xcca69dd3,0x11e3376b,0x08e38fa1,0xd5a62519,0xb784ac20,0x6ac10698,0x6ce16c89,0xb1a4c631,0xd3864f08,0x0ec3e5b0,0x17c35d7a,0xca86f7c2,0xa8a47efb,0x75e1d443,0x9aa50f6f,0x47e0a5d7,0x25c22cee,0xf8878656,0xe1873e9c,0x3cc29424,0x5ee01d1d,0x83a5b7a5,0xf90696d8,0x24433c60,0x4661b559,0x9b241fe1,0x8224a72b,0x5f610d93,0x3d4384aa,0xe0062e12,0x0f42f53e,0xd2075f86,0xb025d6bf,0x6d607c07,0x7460c4cd,0xa9256e75,0xcb07e74c,0x16424df4,0x106227e5,0xcd278d5d,0xaf050464,0x7240aedc,0x6b401616,0xb605bcae,0xd4273597,0x09629f2f,0xe6264403,0x3b63eebb,0x59416782,0x8404cd3a,0x9d0475f0,0x4041df48,0x22635671,0xff26fcc9,0x2e238253,0xf36628eb,0x9144a1d2,0x4c010b6a,0x5501b3a0,0x88441918,0xea669021,0x37233a99,0xd867e1b5,0x05224b0d,0x6700c234,0xba45688c,0xa345d046,0x7e007afe,0x1c22f3c7,0xc167597f,0xc747336e,0x1a0299d6,0x782010ef,0xa565ba57,0xbc65029d,0x6120a825,0x0302211c,0xde478ba4,0x31035088,0xec46fa30,0x8e647309,0x5321d9b1,0x4a21617b,0x9764cbc3,0xf54642fa,0x2803e842}


text:
do { uint32_t c = l ^ LE_LOAD32(p); p += 4; l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^ table1_[(c >> 16) & 0xff] ^ table0_[c >> 24]; } while (0)


text:
= {1,2,3,4,5,6,7,8,9,10,12,14,16,18,20,25,30,35,40,45,50,60,70,80,90,100,120,140,160,180,200,250,300,350,400,450,500,600,700,800,900,1000,1200,1400,1600,1800,2000,2500,3000,3500,4000,4500,5000,6000,7000,8000,9000,10000,12000,14000,16000,18000,20000,25000,30000,35000,40000,45000,50000,60000,70000,80000,90000,100000,120000,140000,160000,180000,200000,250000,300000,350000,400000,450000,500000,600000,700000,800000,900000,1000000,1200000,1400000,1600000,1800000,2000000,2500000,3000000,3500000,4000000,4500000,5000000,6000000,7000000,8000000,9000000,10000000,12000000,14000000,16000000,18000000,20000000,25000000,30000000,35000000,40000000,45000000,50000000,60000000,70000000,80000000,90000000,100000000,120000000,140000000,160000000,180000000,200000000,250000000,300000000,350000000,400000000,450000000,500000000,600000000,700000000,800000000,900000000,1000000000,1200000000,1400000000,1600000000,1800000000,2000000000,2500000000.0,3000000000.0,3500000000.0,4000000000.0,4500000000.0,5000000000.0,6000000000.0,7000000000.0,8000000000.0,9000000000.0,1e200,}


text:
template <class X, class Y> Tester& name(const X& x, const Y& y) { if (! (x op y)) { ss_ << " failed: " << x << (" " #op " ") << y; ok_ = false; } return *this; }


text:
class TCONCAT(_Test_,name) : public base { public: void _Run(); static void _RunIt() { TCONCAT(_Test_,name) t; t._Run(); } }; bool TCONCAT(_Test_ignored_,name) = ::leveldb::test::RegisterTest(#base, #name, &TCONCAT(_Test_,name)::_RunIt); void TCONCAT(_Test_,name)::_Run()


text:
= {QT_TRANSLATE_NOOP("bitcoin-core","" "(1 = keep tx meta data e.g. account owner and payment request information, 2 " "= drop tx meta data)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Allow JSON-RPC connections from specified source. Valid for <ip> are a " "single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or " "a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times"),QT_TRANSLATE_NOOP("bitcoin-core","" "An error occurred while setting up the RPC address %s port %u for listening: " "%s"),QT_TRANSLATE_NOOP("bitcoin-core","" "Bind to given address and always listen on it. Use [host]:port notation for " "IPv6"),QT_TRANSLATE_NOOP("bitcoin-core","" "Bind to given address and whitelist peers connecting to it. Use [host]:port " "notation for IPv6"),QT_TRANSLATE_NOOP("bitcoin-core","" "Bind to given address to listen for JSON-RPC connections. Use [host]:port " "notation for IPv6. This option can be specified multiple times (default: " "bind to all interfaces)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Cannot obtain a lock on data directory %s. Bitcoin Core is probably already " "running."),QT_TRANSLATE_NOOP("bitcoin-core","" "Create new files with system default permissions, instead of umask 077 (only " "effective with disabled wallet functionality)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Delete all wallet transactions and only recover those parts of the " "blockchain through -rescan on startup"),QT_TRANSLATE_NOOP("bitcoin-core","" "Discover own IP addresses (default: 1 when listening and no -externalip or -" "proxy)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Distributed under the MIT software license, see the accompanying file " "COPYING or <http://www.opensource.org/licenses/mit-license.php>."),QT_TRANSLATE_NOOP("bitcoin-core","" "Error: Listening for incoming connections failed (listen returned error %s)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Error: Unsupported argument -socks found. Setting SOCKS version isn't " "possible anymore, only SOCKS5 proxies are supported."),QT_TRANSLATE_NOOP("bitcoin-core","" "Execute command when a relevant alert is received or we see a really long " "fork (%s in cmd is replaced by message)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Execute command when a wallet transaction changes (%s in cmd is replaced by " "TxID)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Execute command when the best block changes (%s in cmd is replaced by block " "hash)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Fees (in BTC/Kb) smaller than this are considered zero fee for relaying " "(default: %s)"),QT_TRANSLATE_NOOP("bitcoin-core","" "How thorough the block verification of -checkblocks is (0-4, default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "If paytxfee is not set, include enough fee so transactions begin " "confirmation on average within n blocks (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Invalid amount for -maxtxfee=<amount>: '%s' (must be at least the minrelay " "fee of %s to prevent stuck transactions)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Maintain a full transaction index, used by the getrawtransaction rpc call " "(default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Maximum size of data in data carrier transactions we relay and mine " "(default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Maximum total fees to use in a single wallet transaction; setting this too " "low may abort large transactions (default: %s)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Number of seconds to keep misbehaving peers from reconnecting (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Output debugging information (default: %u, supplying <category> is optional)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Prune configured below the minimum of %d MB.  Please use a higher number."),QT_TRANSLATE_NOOP("bitcoin-core","" "Query for peer addresses via DNS lookup, if low on addresses (default: 1 " "unless -connect)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Randomize credentials for every proxy connection. This enables Tor stream " "isolation (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Reduce storage requirements by pruning (deleting) old blocks. This mode " "disables wallet support and is incompatible with -txindex. Warning: " "Reverting this setting requires re-downloading the entire blockchain. " "(default: 0 = disable pruning blocks, >%u = target size in MiB to use for " "block files)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Set maximum size of high-priority/low-fee transactions in bytes (default: %d)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Set the number of script verification threads (%u to %d, 0 = auto, <0 = " "leave that many cores free, default: %d)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Set the number of threads for coin generation if enabled (-1 = all cores, " "default: %d)"),QT_TRANSLATE_NOOP("bitcoin-core","" "The transaction amount is too small to send after the fee has been deducted"),QT_TRANSLATE_NOOP("bitcoin-core","" "This is a pre-release test build - use at your own risk - do not use for " "mining or merchant applications"),QT_TRANSLATE_NOOP("bitcoin-core","" "This product includes software developed by the OpenSSL Project for use in " "the OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software " "written by Eric Young and UPnP software written by Thomas Bernard."),QT_TRANSLATE_NOOP("bitcoin-core","" "To use bitcoind, or the -server option to komodo-qt, you must set an " "rpcpassword in the configuration file:\n" "%s\n" "It is recommended you use the following random password:\n" "rpcuser=bitcoinrpc\n" "rpcpassword=%s\n" "(you do not need to remember this password)\n" "The username and password MUST NOT be the same.\n" "If the file does not exist, create it with owner-readable-only file " "permissions.\n" "It is also recommended to set alertnotify so you are notified of problems;\n" "for example: alertnotify=echo %%s | mail -s \"Bitcoin Alert\" admin@foo.com\n"),QT_TRANSLATE_NOOP("bitcoin-core","" "Unable to bind to %s on this computer. Bitcoin Core is probably already " "running."),QT_TRANSLATE_NOOP("bitcoin-core","" "Use separate SOCKS5 proxy to reach peers via Tor hidden services (default: " "%s)"),QT_TRANSLATE_NOOP("bitcoin-core","" "WARNING: abnormally high number of blocks generated, %d blocks received in " "the last %d hours (%d expected)"),QT_TRANSLATE_NOOP("bitcoin-core","" "WARNING: check your network connection, %d blocks received in the last %d " "hours (%d expected)"),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: -maxtxfee is set very high! Fees this large could be paid on a " "single transaction."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: -paytxfee is set very high! This is the transaction fee you will " "pay if you send a transaction."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: Please check that your computer's date and time are correct! If " "your clock is wrong Bitcoin Core will not work properly."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: The network does not appear to fully agree! Some miners appear to " "be experiencing issues."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: We do not appear to fully agree with our peers! You may need to " "upgrade, or other nodes may need to upgrade."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: error reading wallet.dat! All keys read correctly, but transaction " "data or address book entries might be missing or incorrect."),QT_TRANSLATE_NOOP("bitcoin-core","" "Warning: wallet.dat corrupt, data salvaged! Original wallet.dat saved as " "wallet.{timestamp}.bak in %s; if your balance or transactions are incorrect " "you should restore from a backup."),QT_TRANSLATE_NOOP("bitcoin-core","" "Whitelist peers connecting from the given netmask or IP address. Can be " "specified multiple times."),QT_TRANSLATE_NOOP("bitcoin-core","" "Whitelisted peers cannot be DoS banned and their transactions are always " "relayed, even if they are already in the mempool, useful e.g. for a gateway"),QT_TRANSLATE_NOOP("bitcoin-core","" "You need to rebuild the database using -reindex to go back to unpruned " "mode.  This will redownload the entire blockchain"),QT_TRANSLATE_NOOP("bitcoin-core","(default: %s)"),QT_TRANSLATE_NOOP("bitcoin-core","(default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","(default: 1)"),QT_TRANSLATE_NOOP("bitcoin-core","<category> can be:"),QT_TRANSLATE_NOOP("bitcoin-core","Accept command line and JSON-RPC commands"),QT_TRANSLATE_NOOP("bitcoin-core","Accept connections from outside (default: 1 if no -proxy or -connect)"),QT_TRANSLATE_NOOP("bitcoin-core","Accept public REST requests (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Acceptable ciphers (default: %s)"),QT_TRANSLATE_NOOP("bitcoin-core","Activating best chain..."),QT_TRANSLATE_NOOP("bitcoin-core","Add a node to connect to and attempt to keep the connection open"),QT_TRANSLATE_NOOP("bitcoin-core","Allow DNS lookups for -addnode, -seednode and -connect"),QT_TRANSLATE_NOOP("bitcoin-core","Always query for peer addresses via DNS lookup (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Attempt to recover private keys from a corrupt wallet.dat"),QT_TRANSLATE_NOOP("bitcoin-core","Block creation options:"),QT_TRANSLATE_NOOP("bitcoin-core","Can't run with a wallet in prune mode."),QT_TRANSLATE_NOOP("bitcoin-core","Cannot downgrade wallet"),QT_TRANSLATE_NOOP("bitcoin-core","Cannot resolve -bind address: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Cannot resolve -externalip address: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Cannot resolve -whitebind address: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Cannot write default address"),QT_TRANSLATE_NOOP("bitcoin-core","Choose data directory on startup (default: 0)"),QT_TRANSLATE_NOOP("bitcoin-core","Connect only to the specified node(s)"),QT_TRANSLATE_NOOP("bitcoin-core","Connect through SOCKS5 proxy"),QT_TRANSLATE_NOOP("bitcoin-core","Connect to a node to retrieve peer addresses, and disconnect"),QT_TRANSLATE_NOOP("bitcoin-core","Connection options:"),QT_TRANSLATE_NOOP("bitcoin-core","Copyright (C) 2009-%i The Bitcoin Core Developers"),QT_TRANSLATE_NOOP("bitcoin-core","Corrupted block database detected"),QT_TRANSLATE_NOOP("bitcoin-core","Could not parse -rpcbind value %s as network address"),QT_TRANSLATE_NOOP("bitcoin-core","Debugging/Testing options:"),QT_TRANSLATE_NOOP("bitcoin-core","Do not load the wallet and disable wallet RPC calls"),QT_TRANSLATE_NOOP("bitcoin-core","error with HDD data, maybe just need to update to latest version"),QT_TRANSLATE_NOOP("bitcoin-core","Done loading"),QT_TRANSLATE_NOOP("bitcoin-core","Error initializing block database"),QT_TRANSLATE_NOOP("bitcoin-core","Error initializing wallet database environment %s!"),QT_TRANSLATE_NOOP("bitcoin-core","Error loading block database"),QT_TRANSLATE_NOOP("bitcoin-core","Error loading wallet.dat"),QT_TRANSLATE_NOOP("bitcoin-core","Error loading wallet.dat: Wallet corrupted"),QT_TRANSLATE_NOOP("bitcoin-core","Error loading wallet.dat: Wallet requires newer version of Bitcoin Core"),QT_TRANSLATE_NOOP("bitcoin-core","Error opening block database"),QT_TRANSLATE_NOOP("bitcoin-core","Error reading from database, shutting down."),QT_TRANSLATE_NOOP("bitcoin-core","Error"),QT_TRANSLATE_NOOP("bitcoin-core","Error: A fatal internal error occurred, see debug.log for details"),QT_TRANSLATE_NOOP("bitcoin-core","Error: Disk space is low!"),QT_TRANSLATE_NOOP("bitcoin-core","Error: Unsupported argument -tor found, use -onion."),QT_TRANSLATE_NOOP("bitcoin-core","Failed to listen on any port. Use -listen=0 if you want this."),QT_TRANSLATE_NOOP("bitcoin-core","Fee (in BTC/kB) to add to transactions you send (default: %s)"),QT_TRANSLATE_NOOP("bitcoin-core","Generate coins (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","How many blocks to check at startup (default: %u, 0 = all)"),QT_TRANSLATE_NOOP("bitcoin-core","If <category> is not supplied, output all debugging information."),QT_TRANSLATE_NOOP("bitcoin-core","Importing..."),QT_TRANSLATE_NOOP("bitcoin-core","Imports blocks from external blk000??.dat file"),QT_TRANSLATE_NOOP("bitcoin-core","Include IP addresses in debug output (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Incorrect or no genesis block found. Wrong datadir for network?"),QT_TRANSLATE_NOOP("bitcoin-core","Information"),QT_TRANSLATE_NOOP("bitcoin-core","Initialization sanity check failed. Bitcoin Core is shutting down."),QT_TRANSLATE_NOOP("bitcoin-core","Insufficient funds"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid -onion address: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid -proxy address: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid amount for -maxtxfee=<amount>: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid amount for -minrelaytxfee=<amount>: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid amount for -mintxfee=<amount>: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s)"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid amount for -paytxfee=<amount>: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Invalid netmask specified in -whitelist: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Keep at most <n> unconnectable transactions in memory (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Listen for JSON-RPC connections on <port> (default: %u or testnet: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Listen for connections on <port> (default: %u or testnet: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Loading addresses..."),QT_TRANSLATE_NOOP("bitcoin-core","Loading block index..."),QT_TRANSLATE_NOOP("bitcoin-core","Loading wallet..."),QT_TRANSLATE_NOOP("bitcoin-core","Maintain at most <n> connections to peers (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Make the wallet broadcast transactions"),QT_TRANSLATE_NOOP("bitcoin-core","Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Maximum per-connection send buffer, <n>*1000 bytes (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Need to specify a port with -whitebind: '%s'"),QT_TRANSLATE_NOOP("bitcoin-core","Node relay options:"),QT_TRANSLATE_NOOP("bitcoin-core","Not enough file descriptors available."),QT_TRANSLATE_NOOP("bitcoin-core","Only connect to nodes in network <net> (ipv4, ipv6 or onion)"),QT_TRANSLATE_NOOP("bitcoin-core","Options:"),QT_TRANSLATE_NOOP("bitcoin-core","Password for JSON-RPC connections"),QT_TRANSLATE_NOOP("bitcoin-core","Prepend debug output with timestamp (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Prune cannot be configured with a negative value."),QT_TRANSLATE_NOOP("bitcoin-core","Prune mode is incompatible with -txindex."),QT_TRANSLATE_NOOP("bitcoin-core","Pruning blockstore..."),QT_TRANSLATE_NOOP("bitcoin-core","RPC SSL options: (see the Bitcoin Wiki for SSL setup instructions)"),QT_TRANSLATE_NOOP("bitcoin-core","RPC server options:"),QT_TRANSLATE_NOOP("bitcoin-core","RPC support for HTTP persistent connections (default: %d)"),QT_TRANSLATE_NOOP("bitcoin-core","Rebuild block chain index from current blk000??.dat files on startup"),QT_TRANSLATE_NOOP("bitcoin-core","Receive and display P2P network alerts (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Relay and mine data carrier transactions (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Relay non-P2SH multisig (default: %u)"),QT_TRANSLATE_NOOP("bitcoin-core","Rescan the block chain for missing wallet transactions"),QT_TRANSLATE_NOOP("bitcoin-core","Rescanning..."),QT_TRANSLATE_NOOP("bitcoin-core","Run in the background as a daemon and accept commands"),QT_TRANSLATE_NOOP("bitcoin-core","Send trace/debug info to console instead of debug.log file"),QT_TRANSLATE_NOOP("bitcoin-core","Send transactions as zero-fee transactions if possible (default: %u)"),QT_TRANSLATE_NOOP}


text:
= MANDATORY_SCRIPT_VERIFY_FLAGS|SCRIPT_VERIFY_DERSIG|SCRIPT_VERIFY_STRICTENC|SCRIPT_VERIFY_MINIMALDATA|SCRIPT_VERIFY_NULLDUMMY|SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS|SCRIPT_VERIFY_CLEANSTACK|SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY|SCRIPT_VERIFY_LOW_S


text:
= SECP256K1_FE_CONST(0xFFFFFFFFUL,0xFFFFFFFFUL,0xFFFFFFFFUL,0xFFFFFFFEUL,0xBAAEDCE6UL,0xAF48A03BUL,0xBFD25E8CUL,0xD0364141UL)


text:
do { VERIFY_CHECK(((n) & 1) == 1); VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); if ((n) > 0) { *(r) = (pre)[((n)-1)/2]; } else { secp256k1_gej_neg((r), &(pre)[(-(n)-1)/2]); } } while(0)


text:
do { VERIFY_CHECK(((n) & 1) == 1); VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); if ((n) > 0) { secp256k1_ge_from_storage((r), &(pre)[((n)-1)/2]); } else { secp256k1_ge_from_storage((r), &(pre)[(-(n)-1)/2]); secp256k1_ge_neg((r), (r)); } } while(0)


text:
{ (d0) & 0x3FFFFFFUL, ((d0) >> 26) | ((d1) & 0xFFFFFUL) << 6, ((d1) >> 20) | ((d2) & 0x3FFFUL) << 12, ((d2) >> 14) | ((d3) & 0xFFUL) << 18, ((d3) >> 8) | ((d4) & 0x3) << 24, ((d4) >> 2) & 0x3FFFFFFUL, ((d4) >> 28) | ((d5) & 0x3FFFFFUL) << 4, ((d5) >> 22) | ((d6) & 0xFFFF) << 10, ((d6) >> 16) | ((d7) & 0x3FF) << 16, ((d7) >> 10) }


text:
{ (d0) | ((uint64_t)(d1) & 0xFFFFFUL) << 32, ((d1) >> 20) | ((uint64_t)(d2)) << 12 | ((uint64_t)(d3) & 0xFFUL) << 44, ((d3) >> 8) | ((uint64_t)(d4) & 0xFFFFFFFUL) << 24, ((d4) >> 28) | ((uint64_t)(d5)) << 4 | ((uint64_t)(d6) & 0xFFFFUL) << 36, ((d6) >> 16) | ((uint64_t)(d7)) << 16 }


text:
{{ (d0) | ((uint64_t)(d1)) << 32, (d2) | ((uint64_t)(d3)) << 32, (d4) | ((uint64_t)(d5)) << 32, (d6) | ((uint64_t)(d7)) << 32 }}


text:
{SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), 0}


text:
{SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1), 0}


text:
{SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}


text:
{SECP256K1_FE_STORAGE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_STORAGE_CONST((i),(j),(k),(l),(m),(n),(o),(p))}


text:
= SECP256K1_GE_CONST(0x79BE667EUL,0xF9DCBBACUL,0x55A06295UL,0xCE870B07UL,0x029BFCDBUL,0x2DCE28D9UL,0x59F2815BUL,0x16F81798UL,0x483ADA77UL,0x26A3C465UL,0x5DA4FBFCUL,0x0E1108A8UL,0xFD17B448UL,0xA6855419UL,0x9C47D08FUL,0xFB10D4B8UL)


text:
do { uint32_t t1 = (h) + Sigma1(e) + Ch((e), (f), (g)) + (k) + (w); uint32_t t2 = Sigma0(a) + Maj((a), (b), (c)); (d) += t1; (h) = t1 + t2; } while(0)


text:
((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24))


text:
{{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}


text:
{ uint64_t tl, th; { uint128_t t = (uint128_t)a * b; th = t >> 64; tl = t; } c0 += tl; th += (c0 < tl) ? 1 : 0; c1 += th; c2 += (c1 < th) ? 1 : 0; VERIFY_CHECK((c1 >= th) || (c2 != 0)); }


text:
{ uint64_t tl, th; { uint128_t t = (uint128_t)a * b; th = t >> 64; tl = t; } c0 += tl; th += (c0 < tl) ? 1 : 0; c1 += th; VERIFY_CHECK(c1 >= th); }


text:
{ uint64_t tl, th, th2, tl2; { uint128_t t = (uint128_t)a * b; th = t >> 64; tl = t; } th2 = th + th; c2 += (th2 < th) ? 1 : 0; VERIFY_CHECK((th2 >= th) || (c2 != 0)); tl2 = tl + tl; th2 += (tl2 < tl) ? 1 : 0; c0 += tl2; th2 += (c0 < tl2) ? 1 : 0; c2 += (c0 < tl2) & (th2 == 0); VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); c1 += th2; c2 += (c1 < th2) ? 1 : 0; VERIFY_CHECK((c1 >= th2) || (c2 != 0)); }


text:
{ c0 += (a); c1 += (c0 < (a)) ? 1 : 0; VERIFY_CHECK((c1 != 0) | (c0 >= (a))); VERIFY_CHECK(c2 == 0); }


text:
{ uint32_t tl, th; { uint64_t t = (uint64_t)a * b; th = t >> 32; tl = t; } c0 += tl; th += (c0 < tl) ? 1 : 0; c1 += th; c2 += (c1 < th) ? 1 : 0; VERIFY_CHECK((c1 >= th) || (c2 != 0)); }


text:
{ uint32_t tl, th; { uint64_t t = (uint64_t)a * b; th = t >> 32; tl = t; } c0 += tl; th += (c0 < tl) ? 1 : 0; c1 += th; VERIFY_CHECK(c1 >= th); }


text:
{ uint32_t tl, th, th2, tl2; { uint64_t t = (uint64_t)a * b; th = t >> 32; tl = t; } th2 = th + th; c2 += (th2 < th) ? 1 : 0; VERIFY_CHECK((th2 >= th) || (c2 != 0)); tl2 = tl + tl; th2 += (tl2 < tl) ? 1 : 0; c0 += tl2; th2 += (c0 < tl2) ? 1 : 0; c2 += (c0 < tl2) & (th2 == 0); VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); c1 += th2; c2 += (c1 < th2) ? 1 : 0; VERIFY_CHECK((c1 >= th2) || (c2 != 0)); }


text:
struct type##_deleter { void operator()(struct type* ob) { type##_free(ob); }}; typedef std::unique_ptr<struct type, type##_deleter> raii_##type


text:
= "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2" "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d"


text:
= "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf" "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7"


text:
= "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"


text:
= "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"


text:
= "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"


text:
for (unsigned int i = 0; i < 32; ++i) { TmpArray[i] = _A_##Array[i] _OP_ _B_##Array[i]; } BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (_A_##L _OP_ _B_##L));


text:
= TestVector("000102030405060708090a0b0c0d0e0f")("xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8","xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",0x80000000)("xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw","xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",1)("xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ","xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",0x80000002)("xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5","xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",2)("xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV","xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",1000000000)("xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy","xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",0)


text:
= TestVector("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542")("xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB","xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",0)("xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH","xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",0xFFFFFFFF)("xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a","xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",1)("xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon","xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",0xFFFFFFFE)("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL","xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",2)("xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt","xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",0)


text:
(CallRPC("verifymessage t1VtArtnn1dGPiD2WFfMXYXW5mHM3q1GpgV "+retValue.get_str()+" mymessage").get_bool()==false)


text:
(CallRPC("verifymessage "+demoAddress.ToString()+" "+retValue.get_str()+" wrongmessage").get_bool()==false)


text:
(CallRPC("verifymessage "+demoAddress.ToString()+" "+retValue.get_str()+" mymessage").get_bool()==true)


text:
= boost::assign::map_list_of(string("NONE"),(unsigned int)SCRIPT_VERIFY_NONE)(string("P2SH"),(unsigned int)SCRIPT_VERIFY_P2SH)(string("STRICTENC"),(unsigned int)SCRIPT_VERIFY_STRICTENC)(string("DERSIG"),(unsigned int)SCRIPT_VERIFY_DERSIG)(string("LOW_S"),(unsigned int)SCRIPT_VERIFY_LOW_S)(string("SIGPUSHONLY"),(unsigned int)SCRIPT_VERIFY_SIGPUSHONLY)(string("MINIMALDATA"),(unsigned int)SCRIPT_VERIFY_MINIMALDATA)(string("NULLDUMMY"),(unsigned int)SCRIPT_VERIFY_NULLDUMMY)(string("DISCOURAGE_UPGRADABLE_NOPS"),(unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)(string("CLEANSTACK"),(unsigned int)SCRIPT_VERIFY_CLEANSTACK)(string("CHECKLOCKTIMEVERIFY"),(unsigned int)SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)


text:
= "[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]"


text:
= {0x04,0x67,0x8a,0xfd,0xb0,0xfe,0x55,0x48,0x27,0x19,0x67,0xf1,0xa6,0x71,0x30,0xb7,0x10,0x5c,0xd6,0xa8,0x28,0xe0,0x39,0x09,0xa6,0x79,0x62,0xe0,0xea,0x1f,0x61,0xde,0xb6,0x49,0xf6,0xbc,0x3f,0x4c,0xef,0x38,0xc4,0xf3,0x55,0x04,0xe5,0x1e,0xc1,0x12,0xde,0x5c,0x38,0x4d,0xf7,0xba,0x0b,0x8d,0x57,0x8a,0x4c,0x70,0x2b,0x6b,0xf1,0x1d,0x5f}


text:
= {"\\u0000","\\u0001","\\u0002","\\u0003","\\u0004","\\u0005","\\u0006","\\u0007","\\b","\\t","\\n","\\u000b","\\f","\\r","\\u000e","\\u000f","\\u0010","\\u0011","\\u0012","\\u0013","\\u0014","\\u0015","\\u0016","\\u0017","\\u0018","\\u0019","\\u001a","\\u001b","\\u001c","\\u001d","\\u001e","\\u001f",NULL,NULL,"\\\"",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,"\\\\",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,"\\u007f",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,}


text:
= {"fail10.json","fail11.json","fail12.json","fail13.json","fail14.json","fail15.json","fail16.json","fail17.json","fail19.json","fail1.json","fail20.json","fail21.json","fail22.json","fail23.json","fail24.json","fail25.json","fail26.json","fail27.json","fail28.json","fail29.json","fail2.json","fail30.json","fail31.json","fail32.json","fail33.json","fail34.json","fail35.json","fail36.json","fail37.json","fail38.json","fail39.json","fail40.json","fail41.json","fail42.json","fail3.json","fail4.json","fail5.json","fail6.json","fail7.json","fail8.json","fail9.json","pass1.json","pass2.json","pass3.json","round1.json","round2.json","round3.json","round4.json","round5.json","round6.json","round7.json",}


text:
(t_inputs_.begin(),t_inputs_.end(),[](SendManyInputUTXO i,SendManyInputUTXO j)->bool{return(std::get<2>(i)<std::get<2>(j));})


text:
("Still rescanning. At block %d. Progress=%f\n",pindex->nHeight,Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(),pindex))


